diff --git a/base/comment-injection-typescript/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.ts b/head/comment-injection-typescript/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.ts index b5db30e..5ea43d9 100644 --- a/base/comment-injection-typescript/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.ts +++ b/head/comment-injection-typescript/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.ts @@ -149,7 +149,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/comment-injection-typescript/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.ts b/head/comment-injection-typescript/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.ts index 2efa565..e3731c5 100644 --- a/base/comment-injection-typescript/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.ts +++ b/head/comment-injection-typescript/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.ts @@ -155,7 +155,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/comment-injection-typescript/test/inputs/schema/comment-injection-nested-comment.schema/default/TopLevel.ts b/head/comment-injection-typescript/test/inputs/schema/comment-injection-nested-comment.schema/default/TopLevel.ts index f804896..6f0ae2d 100644 --- a/base/comment-injection-typescript/test/inputs/schema/comment-injection-nested-comment.schema/default/TopLevel.ts +++ b/head/comment-injection-typescript/test/inputs/schema/comment-injection-nested-comment.schema/default/TopLevel.ts @@ -147,7 +147,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/comment-injection-typescript/test/inputs/schema/comment-injection.schema/default/TopLevel.ts b/head/comment-injection-typescript/test/inputs/schema/comment-injection.schema/default/TopLevel.ts index 615f083..4a0a168 100644 --- a/base/comment-injection-typescript/test/inputs/schema/comment-injection.schema/default/TopLevel.ts +++ b/head/comment-injection-typescript/test/inputs/schema/comment-injection.schema/default/TopLevel.ts @@ -175,7 +175,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/head/dart/test/inputs/json/priority/combinations1.json/from-map-true--d222f65b3fee/TopLevel.dart b/head/dart/test/inputs/json/priority/combinations1.json/from-map-true--d222f65b3fee/TopLevel.dart new file mode 100644 index 0000000..37bf404 --- /dev/null +++ b/head/dart/test/inputs/json/priority/combinations1.json/from-map-true--d222f65b3fee/TopLevel.dart @@ -0,0 +1,1329 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromMap(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toMap()); + +class TopLevel { + final String centrodesmose; + final List cerograph; + final List chemotherapeutics; + final List cimelia; + final int citrated; + final List clinodome; + final List coadjust; + final List consilience; + final List constructor; + final List continuative; + final List credulity; + final List creviced; + final List> cubiculum; + final List deruralize; + final List diaereses; + final List?> dissolution; + final List downstroke; + final List electrotautomerism; + final List eleutheromania; + final Encrust encrust; + final List entomoid; + final List epipaleolithic; + final List expropriable; + final List faggingly; + final List fenks; + final List flagmaking; + final List fluorometer; + final List fulsome; + final List fuzzy; + final List gardenwards; + final List generalissimo; + final List?> habeas; + final List hemicrystalline; + final List hemocoele; + final List hoister; + final List hyperpiesis; + final List hyppish; + final List idealizer; + final List incrustator; + final List intentiveness; + final Interacinar interacinar; + final List?> intercorrelation; + final List jacutinga; + + TopLevel({ + required this.centrodesmose, + required this.cerograph, + required this.chemotherapeutics, + required this.cimelia, + required this.citrated, + required this.clinodome, + required this.coadjust, + required this.consilience, + required this.constructor, + required this.continuative, + required this.credulity, + required this.creviced, + required this.cubiculum, + required this.deruralize, + required this.diaereses, + required this.dissolution, + required this.downstroke, + required this.electrotautomerism, + required this.eleutheromania, + required this.encrust, + required this.entomoid, + required this.epipaleolithic, + required this.expropriable, + required this.faggingly, + required this.fenks, + required this.flagmaking, + required this.fluorometer, + required this.fulsome, + required this.fuzzy, + required this.gardenwards, + required this.generalissimo, + required this.habeas, + required this.hemicrystalline, + required this.hemocoele, + required this.hoister, + required this.hyperpiesis, + required this.hyppish, + required this.idealizer, + required this.incrustator, + required this.intentiveness, + required this.interacinar, + required this.intercorrelation, + required this.jacutinga, + }); + + factory TopLevel.fromMap(Map json) => TopLevel( + centrodesmose: json["centrodesmose"], + cerograph: List.from(json["cerograph"].map((x) => x)), + chemotherapeutics: List.from(json["chemotherapeutics"].map((x) => x)), + cimelia: List.from(json["cimelia"].map((x) => x)), + citrated: json["citrated"], + clinodome: List.from(json["clinodome"].map((x) => x)), + coadjust: List.from(json["coadjust"].map((x) => x)), + consilience: List.from(json["consilience"].map((x) => x)), + constructor: List.from(json["constructor"].map((x) => x)), + continuative: List.from(json["continuative"].map((x) => x)), + credulity: List.from(json["credulity"].map((x) => x)), + creviced: List.from(json["creviced"].map((x) => x)), + cubiculum: List>.from(json["cubiculum"].map((x) => List.from(x.map((x) => x)))), + deruralize: List.from(json["deruralize"].map((x) => x)), + diaereses: List.from(json["diaereses"].map((x) => x)), + dissolution: List?>.from(json["dissolution"].map((x) => x == null ? null : List.from(x!.map((x) => x)))), + downstroke: List.from(json["downstroke"].map((x) => x)), + electrotautomerism: List.from(json["electrotautomerism"].map((x) => x?.toDouble())), + eleutheromania: List.from(json["eleutheromania"].map((x) => x)), + encrust: Encrust.fromMap(json["encrust"]), + entomoid: List.from(json["entomoid"].map((x) => x)), + epipaleolithic: List.from(json["epipaleolithic"].map((x) => x)), + expropriable: List.from(json["expropriable"].map((x) => x)), + faggingly: List.from(json["faggingly"].map((x) => x)), + fenks: List.from(json["fenks"].map((x) => x)), + flagmaking: List.from(json["flagmaking"].map((x) => x)), + fluorometer: List.from(json["fluorometer"].map((x) => x)), + fulsome: List.from(json["fulsome"].map((x) => x)), + fuzzy: List.from(json["fuzzy"].map((x) => x)), + gardenwards: List.from(json["gardenwards"].map((x) => x)), + generalissimo: List.from(json["generalissimo"].map((x) => x)), + habeas: List?>.from(json["habeas"].map((x) => x == null ? null : Map.from(x!).map((k, v) => MapEntry(k, v)))), + hemicrystalline: List.from(json["hemicrystalline"].map((x) => x)), + hemocoele: List.from(json["hemocoele"].map((x) => x)), + hoister: List.from(json["hoister"].map((x) => x)), + hyperpiesis: List.from(json["hyperpiesis"].map((x) => x)), + hyppish: List.from(json["hyppish"].map((x) => x)), + idealizer: List.from(json["idealizer"].map((x) => x)), + incrustator: List.from(json["incrustator"].map((x) => x)), + intentiveness: List.from(json["intentiveness"].map((x) => x)), + interacinar: Interacinar.fromMap(json["interacinar"]), + intercorrelation: List?>.from(json["intercorrelation"].map((x) => x == null ? null : List.from(x!.map((x) => x)))), + jacutinga: List.from(json["jacutinga"].map((x) => x)), + ); + + Map toMap() => { + "centrodesmose": centrodesmose, + "cerograph": List.from(cerograph.map((x) => x)), + "chemotherapeutics": List.from(chemotherapeutics.map((x) => x)), + "cimelia": List.from(cimelia.map((x) => x)), + "citrated": citrated, + "clinodome": List.from(clinodome.map((x) => x)), + "coadjust": List.from(coadjust.map((x) => x)), + "consilience": List.from(consilience.map((x) => x)), + "constructor": List.from(constructor.map((x) => x)), + "continuative": List.from(continuative.map((x) => x)), + "credulity": List.from(credulity.map((x) => x)), + "creviced": List.from(creviced.map((x) => x)), + "cubiculum": List.from(cubiculum.map((x) => List.from(x.map((x) => x)))), + "deruralize": List.from(deruralize.map((x) => x)), + "diaereses": List.from(diaereses.map((x) => x)), + "dissolution": List.from(dissolution.map((x) => x == null ? null : List.from(x!.map((x) => x)))), + "downstroke": List.from(downstroke.map((x) => x)), + "electrotautomerism": List.from(electrotautomerism.map((x) => x)), + "eleutheromania": List.from(eleutheromania.map((x) => x)), + "encrust": encrust.toMap(), + "entomoid": List.from(entomoid.map((x) => x)), + "epipaleolithic": List.from(epipaleolithic.map((x) => x)), + "expropriable": List.from(expropriable.map((x) => x)), + "faggingly": List.from(faggingly.map((x) => x)), + "fenks": List.from(fenks.map((x) => x)), + "flagmaking": List.from(flagmaking.map((x) => x)), + "fluorometer": List.from(fluorometer.map((x) => x)), + "fulsome": List.from(fulsome.map((x) => x)), + "fuzzy": List.from(fuzzy.map((x) => x)), + "gardenwards": List.from(gardenwards.map((x) => x)), + "generalissimo": List.from(generalissimo.map((x) => x)), + "habeas": List.from(habeas.map((x) => x == null ? null : Map.from(x!).map((k, v) => MapEntry(k, v)))), + "hemicrystalline": List.from(hemicrystalline.map((x) => x)), + "hemocoele": List.from(hemocoele.map((x) => x)), + "hoister": List.from(hoister.map((x) => x)), + "hyperpiesis": List.from(hyperpiesis.map((x) => x)), + "hyppish": List.from(hyppish.map((x) => x)), + "idealizer": List.from(idealizer.map((x) => x)), + "incrustator": List.from(incrustator.map((x) => x)), + "intentiveness": List.from(intentiveness.map((x) => x)), + "interacinar": interacinar.toMap(), + "intercorrelation": List.from(intercorrelation.map((x) => x == null ? null : List.from(x!.map((x) => x)))), + "jacutinga": List.from(jacutinga.map((x) => x)), + }; +} + +class CerographClass { + final dynamic apotropaion; + final dynamic casuary; + final dynamic creaker; + final dynamic disqualification; + final dynamic imperatorious; + final dynamic impermeabilize; + final dynamic metastoma; + final dynamic noctidiurnal; + final dynamic nonreserve; + final dynamic ophthalmotonometry; + final dynamic pailful; + final dynamic pigfish; + final dynamic pongee; + final dynamic prosodical; + final dynamic scrofuloderm; + final dynamic storekeeping; + final dynamic therologist; + final dynamic tolowa; + final dynamic tradeful; + final dynamic unriveting; + + CerographClass({ + required this.apotropaion, + required this.casuary, + required this.creaker, + required this.disqualification, + required this.imperatorious, + required this.impermeabilize, + required this.metastoma, + required this.noctidiurnal, + required this.nonreserve, + required this.ophthalmotonometry, + required this.pailful, + required this.pigfish, + required this.pongee, + required this.prosodical, + required this.scrofuloderm, + required this.storekeeping, + required this.therologist, + required this.tolowa, + required this.tradeful, + required this.unriveting, + }); + + factory CerographClass.fromMap(Map json) => CerographClass( + apotropaion: (json.containsKey("apotropaion") ? json["apotropaion"] : throw FormatException('Missing required property')), + casuary: (json.containsKey("casuary") ? json["casuary"] : throw FormatException('Missing required property')), + creaker: (json.containsKey("creaker") ? json["creaker"] : throw FormatException('Missing required property')), + disqualification: (json.containsKey("disqualification") ? json["disqualification"] : throw FormatException('Missing required property')), + imperatorious: (json.containsKey("imperatorious") ? json["imperatorious"] : throw FormatException('Missing required property')), + impermeabilize: (json.containsKey("impermeabilize") ? json["impermeabilize"] : throw FormatException('Missing required property')), + metastoma: (json.containsKey("metastoma") ? json["metastoma"] : throw FormatException('Missing required property')), + noctidiurnal: (json.containsKey("noctidiurnal") ? json["noctidiurnal"] : throw FormatException('Missing required property')), + nonreserve: (json.containsKey("nonreserve") ? json["nonreserve"] : throw FormatException('Missing required property')), + ophthalmotonometry: (json.containsKey("ophthalmotonometry") ? json["ophthalmotonometry"] : throw FormatException('Missing required property')), + pailful: (json.containsKey("pailful") ? json["pailful"] : throw FormatException('Missing required property')), + pigfish: (json.containsKey("pigfish") ? json["pigfish"] : throw FormatException('Missing required property')), + pongee: (json.containsKey("pongee") ? json["pongee"] : throw FormatException('Missing required property')), + prosodical: (json.containsKey("prosodical") ? json["prosodical"] : throw FormatException('Missing required property')), + scrofuloderm: (json.containsKey("scrofuloderm") ? json["scrofuloderm"] : throw FormatException('Missing required property')), + storekeeping: (json.containsKey("storekeeping") ? json["storekeeping"] : throw FormatException('Missing required property')), + therologist: (json.containsKey("therologist") ? json["therologist"] : throw FormatException('Missing required property')), + tolowa: (json.containsKey("Tolowa") ? json["Tolowa"] : throw FormatException('Missing required property')), + tradeful: (json.containsKey("tradeful") ? json["tradeful"] : throw FormatException('Missing required property')), + unriveting: (json.containsKey("unriveting") ? json["unriveting"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "apotropaion": apotropaion, + "casuary": casuary, + "creaker": creaker, + "disqualification": disqualification, + "imperatorious": imperatorious, + "impermeabilize": impermeabilize, + "metastoma": metastoma, + "noctidiurnal": noctidiurnal, + "nonreserve": nonreserve, + "ophthalmotonometry": ophthalmotonometry, + "pailful": pailful, + "pigfish": pigfish, + "pongee": pongee, + "prosodical": prosodical, + "scrofuloderm": scrofuloderm, + "storekeeping": storekeeping, + "therologist": therologist, + "Tolowa": tolowa, + "tradeful": tradeful, + "unriveting": unriveting, + }; +} + +class ChemotherapeuticClass { + final dynamic angioneurotic; + final dynamic availment; + final dynamic bladelet; + final double? catharticalness; + final dynamic caulis; + final dynamic chalcus; + final int? chirotherium; + final String? disdiapason; + final dynamic enteradenological; + final bool? homocerc; + final dynamic imporosity; + final dynamic insistently; + final dynamic intraparietal; + final dynamic ivied; + final dynamic maureen; + final dynamic nonbookish; + final dynamic nostochine; + final dynamic nutcracker; + final dynamic ofttimes; + final dynamic phenocryst; + final dynamic precoincident; + final dynamic ramiferous; + final dynamic stagmometer; + final dynamic tetherball; + final dynamic unshy; + + ChemotherapeuticClass({ + this.angioneurotic, + this.availment, + this.bladelet, + this.catharticalness, + this.caulis, + this.chalcus, + this.chirotherium, + this.disdiapason, + this.enteradenological, + this.homocerc, + this.imporosity, + this.insistently, + this.intraparietal, + this.ivied, + this.maureen, + this.nonbookish, + this.nostochine, + this.nutcracker, + this.ofttimes, + this.phenocryst, + this.precoincident, + this.ramiferous, + this.stagmometer, + this.tetherball, + this.unshy, + }); + + factory ChemotherapeuticClass.fromMap(Map json) => ChemotherapeuticClass( + angioneurotic: json["angioneurotic"], + availment: json["availment"], + bladelet: json["bladelet"], + catharticalness: json["catharticalness"]?.toDouble(), + caulis: json["caulis"], + chalcus: json["chalcus"], + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + enteradenological: json["enteradenological"], + homocerc: json["homocerc"], + imporosity: json["imporosity"], + insistently: json["insistently"], + intraparietal: json["intraparietal"], + ivied: json["ivied"], + maureen: json["Maureen"], + nonbookish: json["nonbookish"], + nostochine: json["nostochine"], + nutcracker: json["nutcracker"], + ofttimes: json["ofttimes"], + phenocryst: json["phenocryst"], + precoincident: json["precoincident"], + ramiferous: json["ramiferous"], + stagmometer: json["stagmometer"], + tetherball: json["tetherball"], + unshy: json["unshy"], + ); + + Map toMap() => { + "angioneurotic": angioneurotic, + "availment": availment, + "bladelet": bladelet, + "catharticalness": catharticalness, + "caulis": caulis, + "chalcus": chalcus, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "enteradenological": enteradenological, + "homocerc": homocerc, + "imporosity": imporosity, + "insistently": insistently, + "intraparietal": intraparietal, + "ivied": ivied, + "Maureen": maureen, + "nonbookish": nonbookish, + "nostochine": nostochine, + "nutcracker": nutcracker, + "ofttimes": ofttimes, + "phenocryst": phenocryst, + "precoincident": precoincident, + "ramiferous": ramiferous, + "stagmometer": stagmometer, + "tetherball": tetherball, + "unshy": unshy, + }; +} + +class CimeliaClass { + final double catharticalness; + final int chirotherium; + final String disdiapason; + final bool homocerc; + final dynamic nonbookish; + + CimeliaClass({ + required this.catharticalness, + required this.chirotherium, + required this.disdiapason, + required this.homocerc, + required this.nonbookish, + }); + + factory CimeliaClass.fromMap(Map json) => CimeliaClass( + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + homocerc: json["homocerc"], + nonbookish: (json.containsKey("nonbookish") ? json["nonbookish"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "homocerc": homocerc, + "nonbookish": nonbookish, + }; +} + +class CoadjustClass { + final dynamic amidosulphonal; + final dynamic benny; + final double? catharticalness; + final int? chirotherium; + final String? disdiapason; + final dynamic ensnare; + final bool? homocerc; + final dynamic hybridizer; + final dynamic leastwise; + final dynamic lof; + final dynamic monkhood; + final dynamic netherlandish; + final dynamic nonbookish; + final dynamic peonism; + final dynamic phonelescope; + final dynamic porphyrogeniture; + final dynamic preindemnify; + final dynamic rosal; + final dynamic scalenous; + final dynamic scopine; + final dynamic sedaceae; + final dynamic suberinize; + final dynamic symbiot; + final dynamic tablefellow; + final dynamic unchargeable; + + CoadjustClass({ + this.amidosulphonal, + this.benny, + this.catharticalness, + this.chirotherium, + this.disdiapason, + this.ensnare, + this.homocerc, + this.hybridizer, + this.leastwise, + this.lof, + this.monkhood, + this.netherlandish, + this.nonbookish, + this.peonism, + this.phonelescope, + this.porphyrogeniture, + this.preindemnify, + this.rosal, + this.scalenous, + this.scopine, + this.sedaceae, + this.suberinize, + this.symbiot, + this.tablefellow, + this.unchargeable, + }); + + factory CoadjustClass.fromMap(Map json) => CoadjustClass( + amidosulphonal: json["amidosulphonal"], + benny: json["Benny"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + ensnare: json["ensnare"], + homocerc: json["homocerc"], + hybridizer: json["hybridizer"], + leastwise: json["leastwise"], + lof: json["lof"], + monkhood: json["monkhood"], + netherlandish: json["Netherlandish"], + nonbookish: json["nonbookish"], + peonism: json["peonism"], + phonelescope: json["Phonelescope"], + porphyrogeniture: json["porphyrogeniture"], + preindemnify: json["preindemnify"], + rosal: json["rosal"], + scalenous: json["scalenous"], + scopine: json["scopine"], + sedaceae: json["Sedaceae"], + suberinize: json["suberinize"], + symbiot: json["symbiot"], + tablefellow: json["tablefellow"], + unchargeable: json["unchargeable"], + ); + + Map toMap() => { + "amidosulphonal": amidosulphonal, + "Benny": benny, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "ensnare": ensnare, + "homocerc": homocerc, + "hybridizer": hybridizer, + "leastwise": leastwise, + "lof": lof, + "monkhood": monkhood, + "Netherlandish": netherlandish, + "nonbookish": nonbookish, + "peonism": peonism, + "Phonelescope": phonelescope, + "porphyrogeniture": porphyrogeniture, + "preindemnify": preindemnify, + "rosal": rosal, + "scalenous": scalenous, + "scopine": scopine, + "Sedaceae": sedaceae, + "suberinize": suberinize, + "symbiot": symbiot, + "tablefellow": tablefellow, + "unchargeable": unchargeable, + }; +} + +class CredulityClass { + final dynamic ammonolytic; + final dynamic bushmaster; + final dynamic considering; + final dynamic consuetudinary; + final dynamic embarras; + final dynamic fineness; + final dynamic flaithship; + final dynamic flavia; + final dynamic gruffly; + final dynamic hedychium; + final dynamic leadwort; + final dynamic overseriously; + final dynamic parabola; + final dynamic pectinatodenticulate; + final dynamic popean; + final dynamic pornocrat; + final dynamic quadrisect; + final dynamic seriality; + final dynamic vamphorn; + final dynamic wharp; + + CredulityClass({ + required this.ammonolytic, + required this.bushmaster, + required this.considering, + required this.consuetudinary, + required this.embarras, + required this.fineness, + required this.flaithship, + required this.flavia, + required this.gruffly, + required this.hedychium, + required this.leadwort, + required this.overseriously, + required this.parabola, + required this.pectinatodenticulate, + required this.popean, + required this.pornocrat, + required this.quadrisect, + required this.seriality, + required this.vamphorn, + required this.wharp, + }); + + factory CredulityClass.fromMap(Map json) => CredulityClass( + ammonolytic: (json.containsKey("ammonolytic") ? json["ammonolytic"] : throw FormatException('Missing required property')), + bushmaster: (json.containsKey("bushmaster") ? json["bushmaster"] : throw FormatException('Missing required property')), + considering: (json.containsKey("considering") ? json["considering"] : throw FormatException('Missing required property')), + consuetudinary: (json.containsKey("consuetudinary") ? json["consuetudinary"] : throw FormatException('Missing required property')), + embarras: (json.containsKey("embarras") ? json["embarras"] : throw FormatException('Missing required property')), + fineness: (json.containsKey("fineness") ? json["fineness"] : throw FormatException('Missing required property')), + flaithship: (json.containsKey("flaithship") ? json["flaithship"] : throw FormatException('Missing required property')), + flavia: (json.containsKey("Flavia") ? json["Flavia"] : throw FormatException('Missing required property')), + gruffly: (json.containsKey("gruffly") ? json["gruffly"] : throw FormatException('Missing required property')), + hedychium: (json.containsKey("Hedychium") ? json["Hedychium"] : throw FormatException('Missing required property')), + leadwort: (json.containsKey("leadwort") ? json["leadwort"] : throw FormatException('Missing required property')), + overseriously: (json.containsKey("overseriously") ? json["overseriously"] : throw FormatException('Missing required property')), + parabola: (json.containsKey("parabola") ? json["parabola"] : throw FormatException('Missing required property')), + pectinatodenticulate: (json.containsKey("pectinatodenticulate") ? json["pectinatodenticulate"] : throw FormatException('Missing required property')), + popean: (json.containsKey("Popean") ? json["Popean"] : throw FormatException('Missing required property')), + pornocrat: (json.containsKey("pornocrat") ? json["pornocrat"] : throw FormatException('Missing required property')), + quadrisect: (json.containsKey("quadrisect") ? json["quadrisect"] : throw FormatException('Missing required property')), + seriality: (json.containsKey("seriality") ? json["seriality"] : throw FormatException('Missing required property')), + vamphorn: (json.containsKey("vamphorn") ? json["vamphorn"] : throw FormatException('Missing required property')), + wharp: (json.containsKey("wharp") ? json["wharp"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "ammonolytic": ammonolytic, + "bushmaster": bushmaster, + "considering": considering, + "consuetudinary": consuetudinary, + "embarras": embarras, + "fineness": fineness, + "flaithship": flaithship, + "Flavia": flavia, + "gruffly": gruffly, + "Hedychium": hedychium, + "leadwort": leadwort, + "overseriously": overseriously, + "parabola": parabola, + "pectinatodenticulate": pectinatodenticulate, + "Popean": popean, + "pornocrat": pornocrat, + "quadrisect": quadrisect, + "seriality": seriality, + "vamphorn": vamphorn, + "wharp": wharp, + }; +} + +class DeruralizeClass { + final dynamic bockerel; + final dynamic boulder; + final dynamic churrus; + final dynamic counterdigged; + final dynamic dialogite; + final dynamic digenic; + final dynamic dunbird; + final dynamic ergatogyne; + final dynamic fiendful; + final dynamic jackrod; + final dynamic jehovistic; + final dynamic paninean; + final dynamic panther; + final dynamic placentigerous; + final dynamic romney; + final dynamic sparm; + final dynamic tocsin; + final dynamic unnicked; + final dynamic unstavable; + final dynamic windfirm; + + DeruralizeClass({ + required this.bockerel, + required this.boulder, + required this.churrus, + required this.counterdigged, + required this.dialogite, + required this.digenic, + required this.dunbird, + required this.ergatogyne, + required this.fiendful, + required this.jackrod, + required this.jehovistic, + required this.paninean, + required this.panther, + required this.placentigerous, + required this.romney, + required this.sparm, + required this.tocsin, + required this.unnicked, + required this.unstavable, + required this.windfirm, + }); + + factory DeruralizeClass.fromMap(Map json) => DeruralizeClass( + bockerel: (json.containsKey("bockerel") ? json["bockerel"] : throw FormatException('Missing required property')), + boulder: (json.containsKey("boulder") ? json["boulder"] : throw FormatException('Missing required property')), + churrus: (json.containsKey("churrus") ? json["churrus"] : throw FormatException('Missing required property')), + counterdigged: (json.containsKey("counterdigged") ? json["counterdigged"] : throw FormatException('Missing required property')), + dialogite: (json.containsKey("dialogite") ? json["dialogite"] : throw FormatException('Missing required property')), + digenic: (json.containsKey("digenic") ? json["digenic"] : throw FormatException('Missing required property')), + dunbird: (json.containsKey("dunbird") ? json["dunbird"] : throw FormatException('Missing required property')), + ergatogyne: (json.containsKey("ergatogyne") ? json["ergatogyne"] : throw FormatException('Missing required property')), + fiendful: (json.containsKey("fiendful") ? json["fiendful"] : throw FormatException('Missing required property')), + jackrod: (json.containsKey("jackrod") ? json["jackrod"] : throw FormatException('Missing required property')), + jehovistic: (json.containsKey("Jehovistic") ? json["Jehovistic"] : throw FormatException('Missing required property')), + paninean: (json.containsKey("Paninean") ? json["Paninean"] : throw FormatException('Missing required property')), + panther: (json.containsKey("panther") ? json["panther"] : throw FormatException('Missing required property')), + placentigerous: (json.containsKey("placentigerous") ? json["placentigerous"] : throw FormatException('Missing required property')), + romney: (json.containsKey("Romney") ? json["Romney"] : throw FormatException('Missing required property')), + sparm: (json.containsKey("sparm") ? json["sparm"] : throw FormatException('Missing required property')), + tocsin: (json.containsKey("tocsin") ? json["tocsin"] : throw FormatException('Missing required property')), + unnicked: (json.containsKey("unnicked") ? json["unnicked"] : throw FormatException('Missing required property')), + unstavable: (json.containsKey("unstavable") ? json["unstavable"] : throw FormatException('Missing required property')), + windfirm: (json.containsKey("windfirm") ? json["windfirm"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "bockerel": bockerel, + "boulder": boulder, + "churrus": churrus, + "counterdigged": counterdigged, + "dialogite": dialogite, + "digenic": digenic, + "dunbird": dunbird, + "ergatogyne": ergatogyne, + "fiendful": fiendful, + "jackrod": jackrod, + "Jehovistic": jehovistic, + "Paninean": paninean, + "panther": panther, + "placentigerous": placentigerous, + "Romney": romney, + "sparm": sparm, + "tocsin": tocsin, + "unnicked": unnicked, + "unstavable": unstavable, + "windfirm": windfirm, + }; +} + +class DiaereseClass { + final dynamic amoreuxia; + final dynamic ani; + final dynamic bernicle; + final dynamic blackwasher; + final dynamic blowhard; + final dynamic broma; + final dynamic closecross; + final dynamic congregationalism; + final dynamic grayly; + final dynamic historically; + final dynamic hoast; + final dynamic irretentive; + final dynamic parcener; + final dynamic pedder; + final dynamic pseudoanatomic; + final dynamic rhizocarpian; + final dynamic samel; + final dynamic silker; + final dynamic subdentated; + final dynamic subobscure; + + DiaereseClass({ + required this.amoreuxia, + required this.ani, + required this.bernicle, + required this.blackwasher, + required this.blowhard, + required this.broma, + required this.closecross, + required this.congregationalism, + required this.grayly, + required this.historically, + required this.hoast, + required this.irretentive, + required this.parcener, + required this.pedder, + required this.pseudoanatomic, + required this.rhizocarpian, + required this.samel, + required this.silker, + required this.subdentated, + required this.subobscure, + }); + + factory DiaereseClass.fromMap(Map json) => DiaereseClass( + amoreuxia: (json.containsKey("Amoreuxia") ? json["Amoreuxia"] : throw FormatException('Missing required property')), + ani: (json.containsKey("ani") ? json["ani"] : throw FormatException('Missing required property')), + bernicle: (json.containsKey("bernicle") ? json["bernicle"] : throw FormatException('Missing required property')), + blackwasher: (json.containsKey("blackwasher") ? json["blackwasher"] : throw FormatException('Missing required property')), + blowhard: (json.containsKey("blowhard") ? json["blowhard"] : throw FormatException('Missing required property')), + broma: (json.containsKey("broma") ? json["broma"] : throw FormatException('Missing required property')), + closecross: (json.containsKey("closecross") ? json["closecross"] : throw FormatException('Missing required property')), + congregationalism: (json.containsKey("congregationalism") ? json["congregationalism"] : throw FormatException('Missing required property')), + grayly: (json.containsKey("grayly") ? json["grayly"] : throw FormatException('Missing required property')), + historically: (json.containsKey("historically") ? json["historically"] : throw FormatException('Missing required property')), + hoast: (json.containsKey("hoast") ? json["hoast"] : throw FormatException('Missing required property')), + irretentive: (json.containsKey("irretentive") ? json["irretentive"] : throw FormatException('Missing required property')), + parcener: (json.containsKey("parcener") ? json["parcener"] : throw FormatException('Missing required property')), + pedder: (json.containsKey("pedder") ? json["pedder"] : throw FormatException('Missing required property')), + pseudoanatomic: (json.containsKey("pseudoanatomic") ? json["pseudoanatomic"] : throw FormatException('Missing required property')), + rhizocarpian: (json.containsKey("rhizocarpian") ? json["rhizocarpian"] : throw FormatException('Missing required property')), + samel: (json.containsKey("samel") ? json["samel"] : throw FormatException('Missing required property')), + silker: (json.containsKey("silker") ? json["silker"] : throw FormatException('Missing required property')), + subdentated: (json.containsKey("subdentated") ? json["subdentated"] : throw FormatException('Missing required property')), + subobscure: (json.containsKey("subobscure") ? json["subobscure"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "Amoreuxia": amoreuxia, + "ani": ani, + "bernicle": bernicle, + "blackwasher": blackwasher, + "blowhard": blowhard, + "broma": broma, + "closecross": closecross, + "congregationalism": congregationalism, + "grayly": grayly, + "historically": historically, + "hoast": hoast, + "irretentive": irretentive, + "parcener": parcener, + "pedder": pedder, + "pseudoanatomic": pseudoanatomic, + "rhizocarpian": rhizocarpian, + "samel": samel, + "silker": silker, + "subdentated": subdentated, + "subobscure": subobscure, + }; +} + +class Encrust { + final dynamic comradely; + final dynamic diacanthous; + final dynamic feminineness; + final dynamic gossamered; + final dynamic hibernia; + final dynamic hibiscus; + final dynamic lepidosauria; + final dynamic lollingly; + final dynamic manager; + final dynamic mechanic; + final dynamic overminuteness; + final dynamic papelonne; + final dynamic plebification; + final dynamic pugmiller; + final dynamic recoveror; + final dynamic spermatoblastic; + final dynamic syllidae; + final dynamic ungyved; + final dynamic whirlabout; + final dynamic woodenware; + + Encrust({ + required this.comradely, + required this.diacanthous, + required this.feminineness, + required this.gossamered, + required this.hibernia, + required this.hibiscus, + required this.lepidosauria, + required this.lollingly, + required this.manager, + required this.mechanic, + required this.overminuteness, + required this.papelonne, + required this.plebification, + required this.pugmiller, + required this.recoveror, + required this.spermatoblastic, + required this.syllidae, + required this.ungyved, + required this.whirlabout, + required this.woodenware, + }); + + factory Encrust.fromMap(Map json) => Encrust( + comradely: (json.containsKey("comradely") ? json["comradely"] : throw FormatException('Missing required property')), + diacanthous: (json.containsKey("diacanthous") ? json["diacanthous"] : throw FormatException('Missing required property')), + feminineness: (json.containsKey("feminineness") ? json["feminineness"] : throw FormatException('Missing required property')), + gossamered: (json.containsKey("gossamered") ? json["gossamered"] : throw FormatException('Missing required property')), + hibernia: (json.containsKey("Hibernia") ? json["Hibernia"] : throw FormatException('Missing required property')), + hibiscus: (json.containsKey("Hibiscus") ? json["Hibiscus"] : throw FormatException('Missing required property')), + lepidosauria: (json.containsKey("Lepidosauria") ? json["Lepidosauria"] : throw FormatException('Missing required property')), + lollingly: (json.containsKey("lollingly") ? json["lollingly"] : throw FormatException('Missing required property')), + manager: (json.containsKey("manager") ? json["manager"] : throw FormatException('Missing required property')), + mechanic: (json.containsKey("mechanic") ? json["mechanic"] : throw FormatException('Missing required property')), + overminuteness: (json.containsKey("overminuteness") ? json["overminuteness"] : throw FormatException('Missing required property')), + papelonne: (json.containsKey("papelonne") ? json["papelonne"] : throw FormatException('Missing required property')), + plebification: (json.containsKey("plebification") ? json["plebification"] : throw FormatException('Missing required property')), + pugmiller: (json.containsKey("pugmiller") ? json["pugmiller"] : throw FormatException('Missing required property')), + recoveror: (json.containsKey("recoveror") ? json["recoveror"] : throw FormatException('Missing required property')), + spermatoblastic: (json.containsKey("spermatoblastic") ? json["spermatoblastic"] : throw FormatException('Missing required property')), + syllidae: (json.containsKey("Syllidae") ? json["Syllidae"] : throw FormatException('Missing required property')), + ungyved: (json.containsKey("ungyved") ? json["ungyved"] : throw FormatException('Missing required property')), + whirlabout: (json.containsKey("whirlabout") ? json["whirlabout"] : throw FormatException('Missing required property')), + woodenware: (json.containsKey("woodenware") ? json["woodenware"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "comradely": comradely, + "diacanthous": diacanthous, + "feminineness": feminineness, + "gossamered": gossamered, + "Hibernia": hibernia, + "Hibiscus": hibiscus, + "Lepidosauria": lepidosauria, + "lollingly": lollingly, + "manager": manager, + "mechanic": mechanic, + "overminuteness": overminuteness, + "papelonne": papelonne, + "plebification": plebification, + "pugmiller": pugmiller, + "recoveror": recoveror, + "spermatoblastic": spermatoblastic, + "Syllidae": syllidae, + "ungyved": ungyved, + "whirlabout": whirlabout, + "woodenware": woodenware, + }; +} + +class FagginglyClass { + final dynamic abranchian; + final dynamic aculeiform; + final dynamic adiaphoristic; + final dynamic adoptionism; + final dynamic anglic; + final dynamic antrotomy; + final dynamic coerciveness; + final dynamic decorist; + final dynamic duckhood; + final dynamic heteromeri; + final dynamic hypochnose; + final dynamic lochage; + final dynamic melee; + final dynamic nonconformitant; + final dynamic poinsettia; + final dynamic putatively; + final dynamic semivolatile; + final dynamic soleas; + final dynamic unfastenable; + final dynamic unmillinered; + + FagginglyClass({ + required this.abranchian, + required this.aculeiform, + required this.adiaphoristic, + required this.adoptionism, + required this.anglic, + required this.antrotomy, + required this.coerciveness, + required this.decorist, + required this.duckhood, + required this.heteromeri, + required this.hypochnose, + required this.lochage, + required this.melee, + required this.nonconformitant, + required this.poinsettia, + required this.putatively, + required this.semivolatile, + required this.soleas, + required this.unfastenable, + required this.unmillinered, + }); + + factory FagginglyClass.fromMap(Map json) => FagginglyClass( + abranchian: (json.containsKey("abranchian") ? json["abranchian"] : throw FormatException('Missing required property')), + aculeiform: (json.containsKey("aculeiform") ? json["aculeiform"] : throw FormatException('Missing required property')), + adiaphoristic: (json.containsKey("adiaphoristic") ? json["adiaphoristic"] : throw FormatException('Missing required property')), + adoptionism: (json.containsKey("adoptionism") ? json["adoptionism"] : throw FormatException('Missing required property')), + anglic: (json.containsKey("Anglic") ? json["Anglic"] : throw FormatException('Missing required property')), + antrotomy: (json.containsKey("antrotomy") ? json["antrotomy"] : throw FormatException('Missing required property')), + coerciveness: (json.containsKey("coerciveness") ? json["coerciveness"] : throw FormatException('Missing required property')), + decorist: (json.containsKey("decorist") ? json["decorist"] : throw FormatException('Missing required property')), + duckhood: (json.containsKey("duckhood") ? json["duckhood"] : throw FormatException('Missing required property')), + heteromeri: (json.containsKey("Heteromeri") ? json["Heteromeri"] : throw FormatException('Missing required property')), + hypochnose: (json.containsKey("hypochnose") ? json["hypochnose"] : throw FormatException('Missing required property')), + lochage: (json.containsKey("lochage") ? json["lochage"] : throw FormatException('Missing required property')), + melee: (json.containsKey("melee") ? json["melee"] : throw FormatException('Missing required property')), + nonconformitant: (json.containsKey("nonconformitant") ? json["nonconformitant"] : throw FormatException('Missing required property')), + poinsettia: (json.containsKey("Poinsettia") ? json["Poinsettia"] : throw FormatException('Missing required property')), + putatively: (json.containsKey("putatively") ? json["putatively"] : throw FormatException('Missing required property')), + semivolatile: (json.containsKey("semivolatile") ? json["semivolatile"] : throw FormatException('Missing required property')), + soleas: (json.containsKey("soleas") ? json["soleas"] : throw FormatException('Missing required property')), + unfastenable: (json.containsKey("unfastenable") ? json["unfastenable"] : throw FormatException('Missing required property')), + unmillinered: (json.containsKey("unmillinered") ? json["unmillinered"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "abranchian": abranchian, + "aculeiform": aculeiform, + "adiaphoristic": adiaphoristic, + "adoptionism": adoptionism, + "Anglic": anglic, + "antrotomy": antrotomy, + "coerciveness": coerciveness, + "decorist": decorist, + "duckhood": duckhood, + "Heteromeri": heteromeri, + "hypochnose": hypochnose, + "lochage": lochage, + "melee": melee, + "nonconformitant": nonconformitant, + "Poinsettia": poinsettia, + "putatively": putatively, + "semivolatile": semivolatile, + "soleas": soleas, + "unfastenable": unfastenable, + "unmillinered": unmillinered, + }; +} + +class FenkClass { + final dynamic apoise; + final dynamic astronomize; + final dynamic cockhorse; + final dynamic copular; + final dynamic dagomba; + final dynamic draffy; + final dynamic foreigner; + final dynamic guyandot; + final dynamic neurogliosis; + final dynamic osmious; + final dynamic palpitate; + final dynamic rebukeable; + final dynamic reinwardtia; + final dynamic reservatory; + final dynamic scalt; + final dynamic scripturalize; + final dynamic tintometer; + final dynamic tritoness; + final dynamic undergrade; + final dynamic undermountain; + + FenkClass({ + required this.apoise, + required this.astronomize, + required this.cockhorse, + required this.copular, + required this.dagomba, + required this.draffy, + required this.foreigner, + required this.guyandot, + required this.neurogliosis, + required this.osmious, + required this.palpitate, + required this.rebukeable, + required this.reinwardtia, + required this.reservatory, + required this.scalt, + required this.scripturalize, + required this.tintometer, + required this.tritoness, + required this.undergrade, + required this.undermountain, + }); + + factory FenkClass.fromMap(Map json) => FenkClass( + apoise: (json.containsKey("apoise") ? json["apoise"] : throw FormatException('Missing required property')), + astronomize: (json.containsKey("astronomize") ? json["astronomize"] : throw FormatException('Missing required property')), + cockhorse: (json.containsKey("cockhorse") ? json["cockhorse"] : throw FormatException('Missing required property')), + copular: (json.containsKey("copular") ? json["copular"] : throw FormatException('Missing required property')), + dagomba: (json.containsKey("Dagomba") ? json["Dagomba"] : throw FormatException('Missing required property')), + draffy: (json.containsKey("draffy") ? json["draffy"] : throw FormatException('Missing required property')), + foreigner: (json.containsKey("foreigner") ? json["foreigner"] : throw FormatException('Missing required property')), + guyandot: (json.containsKey("Guyandot") ? json["Guyandot"] : throw FormatException('Missing required property')), + neurogliosis: (json.containsKey("neurogliosis") ? json["neurogliosis"] : throw FormatException('Missing required property')), + osmious: (json.containsKey("osmious") ? json["osmious"] : throw FormatException('Missing required property')), + palpitate: (json.containsKey("palpitate") ? json["palpitate"] : throw FormatException('Missing required property')), + rebukeable: (json.containsKey("rebukeable") ? json["rebukeable"] : throw FormatException('Missing required property')), + reinwardtia: (json.containsKey("Reinwardtia") ? json["Reinwardtia"] : throw FormatException('Missing required property')), + reservatory: (json.containsKey("reservatory") ? json["reservatory"] : throw FormatException('Missing required property')), + scalt: (json.containsKey("scalt") ? json["scalt"] : throw FormatException('Missing required property')), + scripturalize: (json.containsKey("scripturalize") ? json["scripturalize"] : throw FormatException('Missing required property')), + tintometer: (json.containsKey("tintometer") ? json["tintometer"] : throw FormatException('Missing required property')), + tritoness: (json.containsKey("Tritoness") ? json["Tritoness"] : throw FormatException('Missing required property')), + undergrade: (json.containsKey("undergrade") ? json["undergrade"] : throw FormatException('Missing required property')), + undermountain: (json.containsKey("undermountain") ? json["undermountain"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "apoise": apoise, + "astronomize": astronomize, + "cockhorse": cockhorse, + "copular": copular, + "Dagomba": dagomba, + "draffy": draffy, + "foreigner": foreigner, + "Guyandot": guyandot, + "neurogliosis": neurogliosis, + "osmious": osmious, + "palpitate": palpitate, + "rebukeable": rebukeable, + "Reinwardtia": reinwardtia, + "reservatory": reservatory, + "scalt": scalt, + "scripturalize": scripturalize, + "tintometer": tintometer, + "Tritoness": tritoness, + "undergrade": undergrade, + "undermountain": undermountain, + }; +} + +class FlagmakingClass { + final dynamic albarco; + final dynamic bunodonta; + final dynamic hornify; + final dynamic hydrocorisae; + final dynamic hypoglossus; + final dynamic inexpiably; + final dynamic ingratitude; + final dynamic ladyfly; + final dynamic medicament; + final dynamic monogrammatic; + final dynamic nobbut; + final dynamic notacanthidae; + final dynamic polyplacophore; + final dynamic proexercise; + final dynamic protoplast; + final dynamic puzzling; + final dynamic splanchnoskeleton; + final dynamic unloveliness; + final dynamic unquarantined; + final dynamic unrenounceable; + + FlagmakingClass({ + required this.albarco, + required this.bunodonta, + required this.hornify, + required this.hydrocorisae, + required this.hypoglossus, + required this.inexpiably, + required this.ingratitude, + required this.ladyfly, + required this.medicament, + required this.monogrammatic, + required this.nobbut, + required this.notacanthidae, + required this.polyplacophore, + required this.proexercise, + required this.protoplast, + required this.puzzling, + required this.splanchnoskeleton, + required this.unloveliness, + required this.unquarantined, + required this.unrenounceable, + }); + + factory FlagmakingClass.fromMap(Map json) => FlagmakingClass( + albarco: (json.containsKey("albarco") ? json["albarco"] : throw FormatException('Missing required property')), + bunodonta: (json.containsKey("Bunodonta") ? json["Bunodonta"] : throw FormatException('Missing required property')), + hornify: (json.containsKey("hornify") ? json["hornify"] : throw FormatException('Missing required property')), + hydrocorisae: (json.containsKey("Hydrocorisae") ? json["Hydrocorisae"] : throw FormatException('Missing required property')), + hypoglossus: (json.containsKey("hypoglossus") ? json["hypoglossus"] : throw FormatException('Missing required property')), + inexpiably: (json.containsKey("inexpiably") ? json["inexpiably"] : throw FormatException('Missing required property')), + ingratitude: (json.containsKey("ingratitude") ? json["ingratitude"] : throw FormatException('Missing required property')), + ladyfly: (json.containsKey("ladyfly") ? json["ladyfly"] : throw FormatException('Missing required property')), + medicament: (json.containsKey("medicament") ? json["medicament"] : throw FormatException('Missing required property')), + monogrammatic: (json.containsKey("monogrammatic") ? json["monogrammatic"] : throw FormatException('Missing required property')), + nobbut: (json.containsKey("nobbut") ? json["nobbut"] : throw FormatException('Missing required property')), + notacanthidae: (json.containsKey("Notacanthidae") ? json["Notacanthidae"] : throw FormatException('Missing required property')), + polyplacophore: (json.containsKey("polyplacophore") ? json["polyplacophore"] : throw FormatException('Missing required property')), + proexercise: (json.containsKey("proexercise") ? json["proexercise"] : throw FormatException('Missing required property')), + protoplast: (json.containsKey("protoplast") ? json["protoplast"] : throw FormatException('Missing required property')), + puzzling: (json.containsKey("puzzling") ? json["puzzling"] : throw FormatException('Missing required property')), + splanchnoskeleton: (json.containsKey("splanchnoskeleton") ? json["splanchnoskeleton"] : throw FormatException('Missing required property')), + unloveliness: (json.containsKey("unloveliness") ? json["unloveliness"] : throw FormatException('Missing required property')), + unquarantined: (json.containsKey("unquarantined") ? json["unquarantined"] : throw FormatException('Missing required property')), + unrenounceable: (json.containsKey("unrenounceable") ? json["unrenounceable"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "albarco": albarco, + "Bunodonta": bunodonta, + "hornify": hornify, + "Hydrocorisae": hydrocorisae, + "hypoglossus": hypoglossus, + "inexpiably": inexpiably, + "ingratitude": ingratitude, + "ladyfly": ladyfly, + "medicament": medicament, + "monogrammatic": monogrammatic, + "nobbut": nobbut, + "Notacanthidae": notacanthidae, + "polyplacophore": polyplacophore, + "proexercise": proexercise, + "protoplast": protoplast, + "puzzling": puzzling, + "splanchnoskeleton": splanchnoskeleton, + "unloveliness": unloveliness, + "unquarantined": unquarantined, + "unrenounceable": unrenounceable, + }; +} + +class HemocoeleClass { + final dynamic acrogamy; + final dynamic amelification; + final dynamic autobiographic; + final dynamic berat; + final double? catharticalness; + final int? chirotherium; + final String? disdiapason; + final dynamic disproportionably; + final dynamic erythrite; + final dynamic graphic; + final dynamic hepatological; + final bool? homocerc; + final dynamic incommensurably; + final dynamic misaffirm; + final dynamic nonbookish; + final dynamic pocketbook; + final dynamic sclerometric; + final dynamic stambouline; + final dynamic stickpin; + final dynamic tubulure; + final dynamic undelated; + final dynamic unsalt; + final dynamic untutelar; + final dynamic vagrant; + final dynamic walt; + + HemocoeleClass({ + this.acrogamy, + this.amelification, + this.autobiographic, + this.berat, + this.catharticalness, + this.chirotherium, + this.disdiapason, + this.disproportionably, + this.erythrite, + this.graphic, + this.hepatological, + this.homocerc, + this.incommensurably, + this.misaffirm, + this.nonbookish, + this.pocketbook, + this.sclerometric, + this.stambouline, + this.stickpin, + this.tubulure, + this.undelated, + this.unsalt, + this.untutelar, + this.vagrant, + this.walt, + }); + + factory HemocoeleClass.fromMap(Map json) => HemocoeleClass( + acrogamy: json["acrogamy"], + amelification: json["amelification"], + autobiographic: json["autobiographic"], + berat: json["berat"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + disproportionably: json["disproportionably"], + erythrite: json["erythrite"], + graphic: json["graphic"], + hepatological: json["hepatological"], + homocerc: json["homocerc"], + incommensurably: json["incommensurably"], + misaffirm: json["misaffirm"], + nonbookish: json["nonbookish"], + pocketbook: json["pocketbook"], + sclerometric: json["sclerometric"], + stambouline: json["stambouline"], + stickpin: json["stickpin"], + tubulure: json["tubulure"], + undelated: json["undelated"], + unsalt: json["unsalt"], + untutelar: json["untutelar"], + vagrant: json["vagrant"], + walt: json["Walt"], + ); + + Map toMap() => { + "acrogamy": acrogamy, + "amelification": amelification, + "autobiographic": autobiographic, + "berat": berat, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "disproportionably": disproportionably, + "erythrite": erythrite, + "graphic": graphic, + "hepatological": hepatological, + "homocerc": homocerc, + "incommensurably": incommensurably, + "misaffirm": misaffirm, + "nonbookish": nonbookish, + "pocketbook": pocketbook, + "sclerometric": sclerometric, + "stambouline": stambouline, + "stickpin": stickpin, + "tubulure": tubulure, + "undelated": undelated, + "unsalt": unsalt, + "untutelar": untutelar, + "vagrant": vagrant, + "Walt": walt, + }; +} + +class Interacinar { + final double assapan; + final bool benefactorship; + final String triseriatim; + final int tubbing; + final dynamic untrimmed; + + Interacinar({ + required this.assapan, + required this.benefactorship, + required this.triseriatim, + required this.tubbing, + required this.untrimmed, + }); + + factory Interacinar.fromMap(Map json) => Interacinar( + assapan: json["assapan"]?.toDouble(), + benefactorship: json["benefactorship"], + triseriatim: json["triseriatim"], + tubbing: json["tubbing"], + untrimmed: (json.containsKey("untrimmed") ? json["untrimmed"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "assapan": assapan, + "benefactorship": benefactorship, + "triseriatim": triseriatim, + "tubbing": tubbing, + "untrimmed": untrimmed, + }; +} diff --git a/head/dart/test/inputs/json/priority/combinations2.json/from-map-true--d222f65b3fee/TopLevel.dart b/head/dart/test/inputs/json/priority/combinations2.json/from-map-true--d222f65b3fee/TopLevel.dart new file mode 100644 index 0000000..215f333 --- /dev/null +++ b/head/dart/test/inputs/json/priority/combinations2.json/from-map-true--d222f65b3fee/TopLevel.dart @@ -0,0 +1,1121 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromMap(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toMap()); + +class TopLevel { + final List abranchiata; + final List academe; + final List acquirable; + final List aerometry; + final List alexin; + final List alleviate; + final List amaas; + final List ambassage; + final List amphithyron; + final List andriana; + final List ankee; + final List?> annihilator; + final dynamic annulose; + final List ansarie; + final List aphasia; + final List asprawl; + final List attractive; + final Map barksome; + final List bedesman; + final List belard; + final List bocking; + final List brawlingly; + final List brookie; + final List bumboatman; + final List bystreet; + final List calaverite; + final List catallactic; + final List cemental; + final List chytridiaceae; + final List discordia; + final List endomyces; + final List epinephelidae; + final List eupatorium; + final List gryphosaurus; + final List koryak; + final List lavinia; + final List oskar; + final List rebecca; + final List rhomboganoidei; + final bool rigsmal; + final List ruellia; + final List school; + final List shakespearolater; + final List svan; + final Map wayao; + + TopLevel({ + required this.abranchiata, + required this.academe, + required this.acquirable, + required this.aerometry, + required this.alexin, + required this.alleviate, + required this.amaas, + required this.ambassage, + required this.amphithyron, + required this.andriana, + required this.ankee, + required this.annihilator, + required this.annulose, + required this.ansarie, + required this.aphasia, + required this.asprawl, + required this.attractive, + required this.barksome, + required this.bedesman, + required this.belard, + required this.bocking, + required this.brawlingly, + required this.brookie, + required this.bumboatman, + required this.bystreet, + required this.calaverite, + required this.catallactic, + required this.cemental, + required this.chytridiaceae, + required this.discordia, + required this.endomyces, + required this.epinephelidae, + required this.eupatorium, + required this.gryphosaurus, + required this.koryak, + required this.lavinia, + required this.oskar, + required this.rebecca, + required this.rhomboganoidei, + required this.rigsmal, + required this.ruellia, + required this.school, + required this.shakespearolater, + required this.svan, + required this.wayao, + }); + + factory TopLevel.fromMap(Map json) => TopLevel( + abranchiata: List.from(json["Abranchiata"].map((x) => x)), + academe: List.from(json["academe"].map((x) => x)), + acquirable: List.from(json["acquirable"].map((x) => x)), + aerometry: List.from(json["aerometry"].map((x) => x)), + alexin: List.from(json["alexin"].map((x) => x)), + alleviate: List.from(json["alleviate"].map((x) => x)), + amaas: List.from(json["amaas"].map((x) => x)), + ambassage: List.from(json["ambassage"].map((x) => x)), + amphithyron: List.from(json["amphithyron"].map((x) => x == null ? null : Amphithyron.fromMap(x))), + andriana: List.from(json["Andriana"].map((x) => x)), + ankee: List.from(json["ankee"].map((x) => x)), + annihilator: List?>.from(json["annihilator"].map((x) => x == null ? null : Map.from(x!).map((k, v) => MapEntry(k, v)))), + annulose: (json.containsKey("annulose") ? json["annulose"] : throw FormatException('Missing required property')), + ansarie: List.from(json["Ansarie"].map((x) => x)), + aphasia: List.from(json["aphasia"].map((x) => x)), + asprawl: List.from(json["asprawl"].map((x) => x)), + attractive: List.from(json["attractive"].map((x) => x)), + barksome: Map.from(json["barksome"]).map((k, v) => MapEntry(k, v)), + bedesman: List.from(json["bedesman"].map((x) => x)), + belard: List.from(json["belard"].map((x) => x)), + bocking: List.from(json["bocking"].map((x) => x)), + brawlingly: List.from(json["brawlingly"].map((x) => x)), + brookie: List.from(json["brookie"].map((x) => x)), + bumboatman: List.from(json["bumboatman"].map((x) => x)), + bystreet: List.from(json["bystreet"].map((x) => x)), + calaverite: List.from(json["calaverite"].map((x) => x)), + catallactic: List.from(json["catallactic"].map((x) => x)), + cemental: List.from(json["cemental"].map((x) => x)), + chytridiaceae: List.from(json["Chytridiaceae"].map((x) => x)), + discordia: List.from(json["Discordia"].map((x) => x)), + endomyces: List.from(json["Endomyces"].map((x) => x)), + epinephelidae: List.from(json["Epinephelidae"].map((x) => x)), + eupatorium: List.from(json["Eupatorium"].map((x) => x)), + gryphosaurus: List.from(json["Gryphosaurus"].map((x) => x)), + koryak: List.from(json["Koryak"].map((x) => x)), + lavinia: List.from(json["Lavinia"].map((x) => x)), + oskar: List.from(json["Oskar"].map((x) => x)), + rebecca: List.from(json["Rebecca"].map((x) => x)), + rhomboganoidei: List.from(json["Rhomboganoidei"].map((x) => x)), + rigsmal: json["Rigsmal"], + ruellia: List.from(json["Ruellia"].map((x) => x)), + school: List.from(json["School"].map((x) => x)), + shakespearolater: List.from(json["Shakespearolater"].map((x) => x)), + svan: List.from(json["Svan"].map((x) => x?.toDouble())), + wayao: Map.from(json["Wayao"]).map((k, v) => MapEntry(k, v?.toDouble())), + ); + + Map toMap() => { + "Abranchiata": List.from(abranchiata.map((x) => x)), + "academe": List.from(academe.map((x) => x)), + "acquirable": List.from(acquirable.map((x) => x)), + "aerometry": List.from(aerometry.map((x) => x)), + "alexin": List.from(alexin.map((x) => x)), + "alleviate": List.from(alleviate.map((x) => x)), + "amaas": List.from(amaas.map((x) => x)), + "ambassage": List.from(ambassage.map((x) => x)), + "amphithyron": List.from(amphithyron.map((x) => x?.toMap())), + "Andriana": List.from(andriana.map((x) => x)), + "ankee": List.from(ankee.map((x) => x)), + "annihilator": List.from(annihilator.map((x) => x == null ? null : Map.from(x!).map((k, v) => MapEntry(k, v)))), + "annulose": annulose, + "Ansarie": List.from(ansarie.map((x) => x)), + "aphasia": List.from(aphasia.map((x) => x)), + "asprawl": List.from(asprawl.map((x) => x)), + "attractive": List.from(attractive.map((x) => x)), + "barksome": Map.from(barksome).map((k, v) => MapEntry(k, v)), + "bedesman": List.from(bedesman.map((x) => x)), + "belard": List.from(belard.map((x) => x)), + "bocking": List.from(bocking.map((x) => x)), + "brawlingly": List.from(brawlingly.map((x) => x)), + "brookie": List.from(brookie.map((x) => x)), + "bumboatman": List.from(bumboatman.map((x) => x)), + "bystreet": List.from(bystreet.map((x) => x)), + "calaverite": List.from(calaverite.map((x) => x)), + "catallactic": List.from(catallactic.map((x) => x)), + "cemental": List.from(cemental.map((x) => x)), + "Chytridiaceae": List.from(chytridiaceae.map((x) => x)), + "Discordia": List.from(discordia.map((x) => x)), + "Endomyces": List.from(endomyces.map((x) => x)), + "Epinephelidae": List.from(epinephelidae.map((x) => x)), + "Eupatorium": List.from(eupatorium.map((x) => x)), + "Gryphosaurus": List.from(gryphosaurus.map((x) => x)), + "Koryak": List.from(koryak.map((x) => x)), + "Lavinia": List.from(lavinia.map((x) => x)), + "Oskar": List.from(oskar.map((x) => x)), + "Rebecca": List.from(rebecca.map((x) => x)), + "Rhomboganoidei": List.from(rhomboganoidei.map((x) => x)), + "Rigsmal": rigsmal, + "Ruellia": List.from(ruellia.map((x) => x)), + "School": List.from(school.map((x) => x)), + "Shakespearolater": List.from(shakespearolater.map((x) => x)), + "Svan": List.from(svan.map((x) => x)), + "Wayao": Map.from(wayao).map((k, v) => MapEntry(k, v)), + }; +} + +class AlleviateClass { + final dynamic apriori; + final dynamic beggarer; + final dynamic brokenheartedly; + final dynamic debilitation; + final dynamic frike; + final dynamic gastrolith; + final dynamic hulsean; + final dynamic orthocentric; + final dynamic petaly; + final dynamic probudgeting; + final dynamic reacquire; + final dynamic scow; + final dynamic shutoff; + final dynamic subcontiguous; + final dynamic suffumigate; + final dynamic transformable; + final dynamic uncoroneted; + final dynamic unparking; + final dynamic unvarnishedness; + final dynamic wherewithal; + + AlleviateClass({ + required this.apriori, + required this.beggarer, + required this.brokenheartedly, + required this.debilitation, + required this.frike, + required this.gastrolith, + required this.hulsean, + required this.orthocentric, + required this.petaly, + required this.probudgeting, + required this.reacquire, + required this.scow, + required this.shutoff, + required this.subcontiguous, + required this.suffumigate, + required this.transformable, + required this.uncoroneted, + required this.unparking, + required this.unvarnishedness, + required this.wherewithal, + }); + + factory AlleviateClass.fromMap(Map json) => AlleviateClass( + apriori: (json.containsKey("apriori") ? json["apriori"] : throw FormatException('Missing required property')), + beggarer: (json.containsKey("beggarer") ? json["beggarer"] : throw FormatException('Missing required property')), + brokenheartedly: (json.containsKey("brokenheartedly") ? json["brokenheartedly"] : throw FormatException('Missing required property')), + debilitation: (json.containsKey("debilitation") ? json["debilitation"] : throw FormatException('Missing required property')), + frike: (json.containsKey("frike") ? json["frike"] : throw FormatException('Missing required property')), + gastrolith: (json.containsKey("gastrolith") ? json["gastrolith"] : throw FormatException('Missing required property')), + hulsean: (json.containsKey("Hulsean") ? json["Hulsean"] : throw FormatException('Missing required property')), + orthocentric: (json.containsKey("orthocentric") ? json["orthocentric"] : throw FormatException('Missing required property')), + petaly: (json.containsKey("petaly") ? json["petaly"] : throw FormatException('Missing required property')), + probudgeting: (json.containsKey("probudgeting") ? json["probudgeting"] : throw FormatException('Missing required property')), + reacquire: (json.containsKey("reacquire") ? json["reacquire"] : throw FormatException('Missing required property')), + scow: (json.containsKey("scow") ? json["scow"] : throw FormatException('Missing required property')), + shutoff: (json.containsKey("shutoff") ? json["shutoff"] : throw FormatException('Missing required property')), + subcontiguous: (json.containsKey("subcontiguous") ? json["subcontiguous"] : throw FormatException('Missing required property')), + suffumigate: (json.containsKey("suffumigate") ? json["suffumigate"] : throw FormatException('Missing required property')), + transformable: (json.containsKey("transformable") ? json["transformable"] : throw FormatException('Missing required property')), + uncoroneted: (json.containsKey("uncoroneted") ? json["uncoroneted"] : throw FormatException('Missing required property')), + unparking: (json.containsKey("unparking") ? json["unparking"] : throw FormatException('Missing required property')), + unvarnishedness: (json.containsKey("unvarnishedness") ? json["unvarnishedness"] : throw FormatException('Missing required property')), + wherewithal: (json.containsKey("wherewithal") ? json["wherewithal"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "apriori": apriori, + "beggarer": beggarer, + "brokenheartedly": brokenheartedly, + "debilitation": debilitation, + "frike": frike, + "gastrolith": gastrolith, + "Hulsean": hulsean, + "orthocentric": orthocentric, + "petaly": petaly, + "probudgeting": probudgeting, + "reacquire": reacquire, + "scow": scow, + "shutoff": shutoff, + "subcontiguous": subcontiguous, + "suffumigate": suffumigate, + "transformable": transformable, + "uncoroneted": uncoroneted, + "unparking": unparking, + "unvarnishedness": unvarnishedness, + "wherewithal": wherewithal, + }; +} + +class Rebecca { + final double catharticalness; + final int chirotherium; + final String disdiapason; + final bool homocerc; + final dynamic nonbookish; + + Rebecca({ + required this.catharticalness, + required this.chirotherium, + required this.disdiapason, + required this.homocerc, + required this.nonbookish, + }); + + factory Rebecca.fromMap(Map json) => Rebecca( + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + homocerc: json["homocerc"], + nonbookish: (json.containsKey("nonbookish") ? json["nonbookish"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disdiapason": disdiapason, + "homocerc": homocerc, + "nonbookish": nonbookish, + }; +} + +class Amphithyron { + final int? akroasis; + final int? antiphonical; + final int? basebred; + final double? catharticalness; + final int? chirotherium; + final int? conductometric; + final String? disdiapason; + final int? ensilation; + final int? eyebolt; + final int? fistulated; + final int? heteropod; + final bool? homocerc; + final int? juniperus; + final int? labyrinthically; + final int? martyrization; + final int? mispolicy; + final int? multipara; + final int? nazirite; + final dynamic nonbookish; + final int? possessorial; + final int? shamed; + final int? shelfworn; + final int? stagnum; + final int? those; + final int? undecimal; + + Amphithyron({ + this.akroasis, + this.antiphonical, + this.basebred, + this.catharticalness, + this.chirotherium, + this.conductometric, + this.disdiapason, + this.ensilation, + this.eyebolt, + this.fistulated, + this.heteropod, + this.homocerc, + this.juniperus, + this.labyrinthically, + this.martyrization, + this.mispolicy, + this.multipara, + this.nazirite, + this.nonbookish, + this.possessorial, + this.shamed, + this.shelfworn, + this.stagnum, + this.those, + this.undecimal, + }); + + factory Amphithyron.fromMap(Map json) => Amphithyron( + akroasis: json["akroasis"], + antiphonical: json["antiphonical"], + basebred: json["basebred"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + conductometric: json["conductometric"], + disdiapason: json["disdiapason"], + ensilation: json["ensilation"], + eyebolt: json["eyebolt"], + fistulated: json["fistulated"], + heteropod: json["heteropod"], + homocerc: json["homocerc"], + juniperus: json["Juniperus"], + labyrinthically: json["labyrinthically"], + martyrization: json["martyrization"], + mispolicy: json["mispolicy"], + multipara: json["multipara"], + nazirite: json["Nazirite"], + nonbookish: json["nonbookish"], + possessorial: json["possessorial"], + shamed: json["shamed"], + shelfworn: json["shelfworn"], + stagnum: json["stagnum"], + those: json["Those"], + undecimal: json["undecimal"], + ); + + Map toMap() => { + "akroasis": akroasis, + "antiphonical": antiphonical, + "basebred": basebred, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "conductometric": conductometric, + "disdiapason": disdiapason, + "ensilation": ensilation, + "eyebolt": eyebolt, + "fistulated": fistulated, + "heteropod": heteropod, + "homocerc": homocerc, + "Juniperus": juniperus, + "labyrinthically": labyrinthically, + "martyrization": martyrization, + "mispolicy": mispolicy, + "multipara": multipara, + "Nazirite": nazirite, + "nonbookish": nonbookish, + "possessorial": possessorial, + "shamed": shamed, + "shelfworn": shelfworn, + "stagnum": stagnum, + "Those": those, + "undecimal": undecimal, + }; +} + +class AnkeeClass { + final dynamic anomoean; + final dynamic barleyhood; + final dynamic befriender; + final dynamic brutishness; + final dynamic cephalalgy; + final dynamic cirurgian; + final dynamic conventionally; + final dynamic jackshay; + final dynamic milammeter; + final dynamic naja; + final dynamic ombrological; + final dynamic phonasthenia; + final dynamic retrievableness; + final dynamic snakily; + final dynamic swot; + final dynamic tartlet; + final dynamic thiofuran; + final dynamic tracheophone; + final dynamic tuglike; + final dynamic unscratchingly; + + AnkeeClass({ + required this.anomoean, + required this.barleyhood, + required this.befriender, + required this.brutishness, + required this.cephalalgy, + required this.cirurgian, + required this.conventionally, + required this.jackshay, + required this.milammeter, + required this.naja, + required this.ombrological, + required this.phonasthenia, + required this.retrievableness, + required this.snakily, + required this.swot, + required this.tartlet, + required this.thiofuran, + required this.tracheophone, + required this.tuglike, + required this.unscratchingly, + }); + + factory AnkeeClass.fromMap(Map json) => AnkeeClass( + anomoean: (json.containsKey("Anomoean") ? json["Anomoean"] : throw FormatException('Missing required property')), + barleyhood: (json.containsKey("barleyhood") ? json["barleyhood"] : throw FormatException('Missing required property')), + befriender: (json.containsKey("befriender") ? json["befriender"] : throw FormatException('Missing required property')), + brutishness: (json.containsKey("brutishness") ? json["brutishness"] : throw FormatException('Missing required property')), + cephalalgy: (json.containsKey("cephalalgy") ? json["cephalalgy"] : throw FormatException('Missing required property')), + cirurgian: (json.containsKey("cirurgian") ? json["cirurgian"] : throw FormatException('Missing required property')), + conventionally: (json.containsKey("conventionally") ? json["conventionally"] : throw FormatException('Missing required property')), + jackshay: (json.containsKey("jackshay") ? json["jackshay"] : throw FormatException('Missing required property')), + milammeter: (json.containsKey("milammeter") ? json["milammeter"] : throw FormatException('Missing required property')), + naja: (json.containsKey("Naja") ? json["Naja"] : throw FormatException('Missing required property')), + ombrological: (json.containsKey("ombrological") ? json["ombrological"] : throw FormatException('Missing required property')), + phonasthenia: (json.containsKey("phonasthenia") ? json["phonasthenia"] : throw FormatException('Missing required property')), + retrievableness: (json.containsKey("retrievableness") ? json["retrievableness"] : throw FormatException('Missing required property')), + snakily: (json.containsKey("snakily") ? json["snakily"] : throw FormatException('Missing required property')), + swot: (json.containsKey("swot") ? json["swot"] : throw FormatException('Missing required property')), + tartlet: (json.containsKey("tartlet") ? json["tartlet"] : throw FormatException('Missing required property')), + thiofuran: (json.containsKey("thiofuran") ? json["thiofuran"] : throw FormatException('Missing required property')), + tracheophone: (json.containsKey("tracheophone") ? json["tracheophone"] : throw FormatException('Missing required property')), + tuglike: (json.containsKey("tuglike") ? json["tuglike"] : throw FormatException('Missing required property')), + unscratchingly: (json.containsKey("unscratchingly") ? json["unscratchingly"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "Anomoean": anomoean, + "barleyhood": barleyhood, + "befriender": befriender, + "brutishness": brutishness, + "cephalalgy": cephalalgy, + "cirurgian": cirurgian, + "conventionally": conventionally, + "jackshay": jackshay, + "milammeter": milammeter, + "Naja": naja, + "ombrological": ombrological, + "phonasthenia": phonasthenia, + "retrievableness": retrievableness, + "snakily": snakily, + "swot": swot, + "tartlet": tartlet, + "thiofuran": thiofuran, + "tracheophone": tracheophone, + "tuglike": tuglike, + "unscratchingly": unscratchingly, + }; +} + +class AnsarieClass { + final dynamic accension; + final dynamic alida; + final dynamic asteria; + final dynamic beriberic; + final dynamic edgebone; + final dynamic gastrodialysis; + final dynamic geographic; + final dynamic ictonyx; + final dynamic metrocele; + final dynamic misgraft; + final dynamic monteith; + final dynamic notcher; + final dynamic prorestriction; + final dynamic ramist; + final dynamic throatlet; + final dynamic unfair; + final dynamic unsynonymous; + final dynamic water; + final dynamic zestfully; + final dynamic zincic; + + AnsarieClass({ + required this.accension, + required this.alida, + required this.asteria, + required this.beriberic, + required this.edgebone, + required this.gastrodialysis, + required this.geographic, + required this.ictonyx, + required this.metrocele, + required this.misgraft, + required this.monteith, + required this.notcher, + required this.prorestriction, + required this.ramist, + required this.throatlet, + required this.unfair, + required this.unsynonymous, + required this.water, + required this.zestfully, + required this.zincic, + }); + + factory AnsarieClass.fromMap(Map json) => AnsarieClass( + accension: (json.containsKey("accension") ? json["accension"] : throw FormatException('Missing required property')), + alida: (json.containsKey("Alida") ? json["Alida"] : throw FormatException('Missing required property')), + asteria: (json.containsKey("asteria") ? json["asteria"] : throw FormatException('Missing required property')), + beriberic: (json.containsKey("beriberic") ? json["beriberic"] : throw FormatException('Missing required property')), + edgebone: (json.containsKey("edgebone") ? json["edgebone"] : throw FormatException('Missing required property')), + gastrodialysis: (json.containsKey("gastrodialysis") ? json["gastrodialysis"] : throw FormatException('Missing required property')), + geographic: (json.containsKey("geographic") ? json["geographic"] : throw FormatException('Missing required property')), + ictonyx: (json.containsKey("Ictonyx") ? json["Ictonyx"] : throw FormatException('Missing required property')), + metrocele: (json.containsKey("metrocele") ? json["metrocele"] : throw FormatException('Missing required property')), + misgraft: (json.containsKey("misgraft") ? json["misgraft"] : throw FormatException('Missing required property')), + monteith: (json.containsKey("monteith") ? json["monteith"] : throw FormatException('Missing required property')), + notcher: (json.containsKey("notcher") ? json["notcher"] : throw FormatException('Missing required property')), + prorestriction: (json.containsKey("prorestriction") ? json["prorestriction"] : throw FormatException('Missing required property')), + ramist: (json.containsKey("Ramist") ? json["Ramist"] : throw FormatException('Missing required property')), + throatlet: (json.containsKey("throatlet") ? json["throatlet"] : throw FormatException('Missing required property')), + unfair: (json.containsKey("unfair") ? json["unfair"] : throw FormatException('Missing required property')), + unsynonymous: (json.containsKey("unsynonymous") ? json["unsynonymous"] : throw FormatException('Missing required property')), + water: (json.containsKey("water") ? json["water"] : throw FormatException('Missing required property')), + zestfully: (json.containsKey("zestfully") ? json["zestfully"] : throw FormatException('Missing required property')), + zincic: (json.containsKey("zincic") ? json["zincic"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "accension": accension, + "Alida": alida, + "asteria": asteria, + "beriberic": beriberic, + "edgebone": edgebone, + "gastrodialysis": gastrodialysis, + "geographic": geographic, + "Ictonyx": ictonyx, + "metrocele": metrocele, + "misgraft": misgraft, + "monteith": monteith, + "notcher": notcher, + "prorestriction": prorestriction, + "Ramist": ramist, + "throatlet": throatlet, + "unfair": unfair, + "unsynonymous": unsynonymous, + "water": water, + "zestfully": zestfully, + "zincic": zincic, + }; +} + +class ChytridiaceaeClass { + final dynamic batidaceae; + final dynamic brechites; + final dynamic codespairer; + final dynamic emery; + final dynamic enervative; + final dynamic excriminate; + final dynamic goshenite; + final dynamic grime; + final dynamic gritten; + final dynamic hectorly; + final dynamic intermediation; + final dynamic meeterly; + final dynamic narraganset; + final dynamic onymatic; + final dynamic paddlecock; + final dynamic thana; + final dynamic thornily; + final dynamic uckia; + final dynamic unmettle; + final dynamic vorticellid; + + ChytridiaceaeClass({ + required this.batidaceae, + required this.brechites, + required this.codespairer, + required this.emery, + required this.enervative, + required this.excriminate, + required this.goshenite, + required this.grime, + required this.gritten, + required this.hectorly, + required this.intermediation, + required this.meeterly, + required this.narraganset, + required this.onymatic, + required this.paddlecock, + required this.thana, + required this.thornily, + required this.uckia, + required this.unmettle, + required this.vorticellid, + }); + + factory ChytridiaceaeClass.fromMap(Map json) => ChytridiaceaeClass( + batidaceae: (json.containsKey("Batidaceae") ? json["Batidaceae"] : throw FormatException('Missing required property')), + brechites: (json.containsKey("Brechites") ? json["Brechites"] : throw FormatException('Missing required property')), + codespairer: (json.containsKey("codespairer") ? json["codespairer"] : throw FormatException('Missing required property')), + emery: (json.containsKey("Emery") ? json["Emery"] : throw FormatException('Missing required property')), + enervative: (json.containsKey("enervative") ? json["enervative"] : throw FormatException('Missing required property')), + excriminate: (json.containsKey("excriminate") ? json["excriminate"] : throw FormatException('Missing required property')), + goshenite: (json.containsKey("goshenite") ? json["goshenite"] : throw FormatException('Missing required property')), + grime: (json.containsKey("grime") ? json["grime"] : throw FormatException('Missing required property')), + gritten: (json.containsKey("gritten") ? json["gritten"] : throw FormatException('Missing required property')), + hectorly: (json.containsKey("hectorly") ? json["hectorly"] : throw FormatException('Missing required property')), + intermediation: (json.containsKey("intermediation") ? json["intermediation"] : throw FormatException('Missing required property')), + meeterly: (json.containsKey("meeterly") ? json["meeterly"] : throw FormatException('Missing required property')), + narraganset: (json.containsKey("Narraganset") ? json["Narraganset"] : throw FormatException('Missing required property')), + onymatic: (json.containsKey("onymatic") ? json["onymatic"] : throw FormatException('Missing required property')), + paddlecock: (json.containsKey("paddlecock") ? json["paddlecock"] : throw FormatException('Missing required property')), + thana: (json.containsKey("thana") ? json["thana"] : throw FormatException('Missing required property')), + thornily: (json.containsKey("thornily") ? json["thornily"] : throw FormatException('Missing required property')), + uckia: (json.containsKey("uckia") ? json["uckia"] : throw FormatException('Missing required property')), + unmettle: (json.containsKey("unmettle") ? json["unmettle"] : throw FormatException('Missing required property')), + vorticellid: (json.containsKey("vorticellid") ? json["vorticellid"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "Batidaceae": batidaceae, + "Brechites": brechites, + "codespairer": codespairer, + "Emery": emery, + "enervative": enervative, + "excriminate": excriminate, + "goshenite": goshenite, + "grime": grime, + "gritten": gritten, + "hectorly": hectorly, + "intermediation": intermediation, + "meeterly": meeterly, + "Narraganset": narraganset, + "onymatic": onymatic, + "paddlecock": paddlecock, + "thana": thana, + "thornily": thornily, + "uckia": uckia, + "unmettle": unmettle, + "vorticellid": vorticellid, + }; +} + +class DiscordiaClass { + final int? altaic; + final int? amoristic; + final int? blennophthalmia; + final double? catharticalness; + final int? chirotherium; + final int? disciplinability; + final String? disdiapason; + final int? goofer; + final bool? homocerc; + final int? laryngograph; + final int? leucitis; + final int? lymphocyst; + final int? microcosmology; + final int? nauseation; + final dynamic nonbookish; + final int? patarin; + final int? preliberal; + final int? prettifier; + final int? rangework; + final int? redient; + final int? subfusiform; + final int? suicidical; + final int? swow; + final int? wastrel; + final int? wingle; + + DiscordiaClass({ + this.altaic, + this.amoristic, + this.blennophthalmia, + this.catharticalness, + this.chirotherium, + this.disciplinability, + this.disdiapason, + this.goofer, + this.homocerc, + this.laryngograph, + this.leucitis, + this.lymphocyst, + this.microcosmology, + this.nauseation, + this.nonbookish, + this.patarin, + this.preliberal, + this.prettifier, + this.rangework, + this.redient, + this.subfusiform, + this.suicidical, + this.swow, + this.wastrel, + this.wingle, + }); + + factory DiscordiaClass.fromMap(Map json) => DiscordiaClass( + altaic: json["Altaic"], + amoristic: json["amoristic"], + blennophthalmia: json["blennophthalmia"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disciplinability: json["disciplinability"], + disdiapason: json["disdiapason"], + goofer: json["goofer"], + homocerc: json["homocerc"], + laryngograph: json["laryngograph"], + leucitis: json["leucitis"], + lymphocyst: json["lymphocyst"], + microcosmology: json["microcosmology"], + nauseation: json["nauseation"], + nonbookish: json["nonbookish"], + patarin: json["Patarin"], + preliberal: json["preliberal"], + prettifier: json["prettifier"], + rangework: json["rangework"], + redient: json["redient"], + subfusiform: json["subfusiform"], + suicidical: json["suicidical"], + swow: json["swow"], + wastrel: json["wastrel"], + wingle: json["wingle"], + ); + + Map toMap() => { + "Altaic": altaic, + "amoristic": amoristic, + "blennophthalmia": blennophthalmia, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "disciplinability": disciplinability, + "disdiapason": disdiapason, + "goofer": goofer, + "homocerc": homocerc, + "laryngograph": laryngograph, + "leucitis": leucitis, + "lymphocyst": lymphocyst, + "microcosmology": microcosmology, + "nauseation": nauseation, + "nonbookish": nonbookish, + "Patarin": patarin, + "preliberal": preliberal, + "prettifier": prettifier, + "rangework": rangework, + "redient": redient, + "subfusiform": subfusiform, + "suicidical": suicidical, + "swow": swow, + "wastrel": wastrel, + "wingle": wingle, + }; +} + +class GryphosaurusClass { + final dynamic amissibility; + final dynamic burushaski; + final dynamic citronin; + final dynamic coplaintiff; + final dynamic disquisitionary; + final dynamic enoplan; + final dynamic faintness; + final dynamic hebetomy; + final dynamic islandry; + final dynamic lameduck; + final dynamic overbattle; + final dynamic overinterested; + final dynamic phrenologic; + final dynamic rainband; + final dynamic shiningly; + final dynamic stamineous; + final dynamic subscapularis; + final dynamic tahami; + final dynamic undaubed; + final dynamic underntime; + + GryphosaurusClass({ + required this.amissibility, + required this.burushaski, + required this.citronin, + required this.coplaintiff, + required this.disquisitionary, + required this.enoplan, + required this.faintness, + required this.hebetomy, + required this.islandry, + required this.lameduck, + required this.overbattle, + required this.overinterested, + required this.phrenologic, + required this.rainband, + required this.shiningly, + required this.stamineous, + required this.subscapularis, + required this.tahami, + required this.undaubed, + required this.underntime, + }); + + factory GryphosaurusClass.fromMap(Map json) => GryphosaurusClass( + amissibility: (json.containsKey("amissibility") ? json["amissibility"] : throw FormatException('Missing required property')), + burushaski: (json.containsKey("Burushaski") ? json["Burushaski"] : throw FormatException('Missing required property')), + citronin: (json.containsKey("citronin") ? json["citronin"] : throw FormatException('Missing required property')), + coplaintiff: (json.containsKey("coplaintiff") ? json["coplaintiff"] : throw FormatException('Missing required property')), + disquisitionary: (json.containsKey("disquisitionary") ? json["disquisitionary"] : throw FormatException('Missing required property')), + enoplan: (json.containsKey("enoplan") ? json["enoplan"] : throw FormatException('Missing required property')), + faintness: (json.containsKey("faintness") ? json["faintness"] : throw FormatException('Missing required property')), + hebetomy: (json.containsKey("hebetomy") ? json["hebetomy"] : throw FormatException('Missing required property')), + islandry: (json.containsKey("islandry") ? json["islandry"] : throw FormatException('Missing required property')), + lameduck: (json.containsKey("lameduck") ? json["lameduck"] : throw FormatException('Missing required property')), + overbattle: (json.containsKey("overbattle") ? json["overbattle"] : throw FormatException('Missing required property')), + overinterested: (json.containsKey("overinterested") ? json["overinterested"] : throw FormatException('Missing required property')), + phrenologic: (json.containsKey("phrenologic") ? json["phrenologic"] : throw FormatException('Missing required property')), + rainband: (json.containsKey("rainband") ? json["rainband"] : throw FormatException('Missing required property')), + shiningly: (json.containsKey("shiningly") ? json["shiningly"] : throw FormatException('Missing required property')), + stamineous: (json.containsKey("stamineous") ? json["stamineous"] : throw FormatException('Missing required property')), + subscapularis: (json.containsKey("subscapularis") ? json["subscapularis"] : throw FormatException('Missing required property')), + tahami: (json.containsKey("Tahami") ? json["Tahami"] : throw FormatException('Missing required property')), + undaubed: (json.containsKey("undaubed") ? json["undaubed"] : throw FormatException('Missing required property')), + underntime: (json.containsKey("underntime") ? json["underntime"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "amissibility": amissibility, + "Burushaski": burushaski, + "citronin": citronin, + "coplaintiff": coplaintiff, + "disquisitionary": disquisitionary, + "enoplan": enoplan, + "faintness": faintness, + "hebetomy": hebetomy, + "islandry": islandry, + "lameduck": lameduck, + "overbattle": overbattle, + "overinterested": overinterested, + "phrenologic": phrenologic, + "rainband": rainband, + "shiningly": shiningly, + "stamineous": stamineous, + "subscapularis": subscapularis, + "Tahami": tahami, + "undaubed": undaubed, + "underntime": underntime, + }; +} + +class LaviniaClass { + final int? agitable; + final int? asininity; + final int? benefiter; + final int? bronzelike; + final double? catharticalness; + final int? chirotherium; + final int? cholesteatomatous; + final int? deprivement; + final String? disdiapason; + final int? flippantness; + final int? fogproof; + final bool? homocerc; + final int? merrymeeting; + final dynamic nonbookish; + final int? overcareful; + final int? panaris; + final int? preacceptance; + final int? quinoxaline; + final int? sig; + final int? superconfusion; + final int? tacana; + final int? tillotter; + final int? tranquillize; + final int? unquestionable; + final int? uproute; + + LaviniaClass({ + this.agitable, + this.asininity, + this.benefiter, + this.bronzelike, + this.catharticalness, + this.chirotherium, + this.cholesteatomatous, + this.deprivement, + this.disdiapason, + this.flippantness, + this.fogproof, + this.homocerc, + this.merrymeeting, + this.nonbookish, + this.overcareful, + this.panaris, + this.preacceptance, + this.quinoxaline, + this.sig, + this.superconfusion, + this.tacana, + this.tillotter, + this.tranquillize, + this.unquestionable, + this.uproute, + }); + + factory LaviniaClass.fromMap(Map json) => LaviniaClass( + agitable: json["agitable"], + asininity: json["asininity"], + benefiter: json["benefiter"], + bronzelike: json["bronzelike"], + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + cholesteatomatous: json["cholesteatomatous"], + deprivement: json["deprivement"], + disdiapason: json["disdiapason"], + flippantness: json["flippantness"], + fogproof: json["fogproof"], + homocerc: json["homocerc"], + merrymeeting: json["merrymeeting"], + nonbookish: json["nonbookish"], + overcareful: json["overcareful"], + panaris: json["panaris"], + preacceptance: json["preacceptance"], + quinoxaline: json["quinoxaline"], + sig: json["sig"], + superconfusion: json["superconfusion"], + tacana: json["Tacana"], + tillotter: json["tillotter"], + tranquillize: json["tranquillize"], + unquestionable: json["unquestionable"], + uproute: json["uproute"], + ); + + Map toMap() => { + "agitable": agitable, + "asininity": asininity, + "benefiter": benefiter, + "bronzelike": bronzelike, + "catharticalness": catharticalness, + "Chirotherium": chirotherium, + "cholesteatomatous": cholesteatomatous, + "deprivement": deprivement, + "disdiapason": disdiapason, + "flippantness": flippantness, + "fogproof": fogproof, + "homocerc": homocerc, + "merrymeeting": merrymeeting, + "nonbookish": nonbookish, + "overcareful": overcareful, + "panaris": panaris, + "preacceptance": preacceptance, + "quinoxaline": quinoxaline, + "sig": sig, + "superconfusion": superconfusion, + "Tacana": tacana, + "tillotter": tillotter, + "tranquillize": tranquillize, + "unquestionable": unquestionable, + "uproute": uproute, + }; +} + +class OskarClass { + final dynamic acrobates; + final dynamic beanshooter; + final dynamic bearhound; + final dynamic cayuga; + final dynamic guarneri; + final dynamic hypochondriacism; + final dynamic indication; + final dynamic jaculative; + final dynamic nagana; + final dynamic netherlandish; + final dynamic noctivagous; + final dynamic nonphysiological; + final dynamic praxis; + final dynamic provision; + final dynamic subterhuman; + final dynamic sunlit; + final dynamic syncraniate; + final dynamic teachment; + final dynamic unmutinous; + final dynamic unstoppable; + + OskarClass({ + required this.acrobates, + required this.beanshooter, + required this.bearhound, + required this.cayuga, + required this.guarneri, + required this.hypochondriacism, + required this.indication, + required this.jaculative, + required this.nagana, + required this.netherlandish, + required this.noctivagous, + required this.nonphysiological, + required this.praxis, + required this.provision, + required this.subterhuman, + required this.sunlit, + required this.syncraniate, + required this.teachment, + required this.unmutinous, + required this.unstoppable, + }); + + factory OskarClass.fromMap(Map json) => OskarClass( + acrobates: (json.containsKey("Acrobates") ? json["Acrobates"] : throw FormatException('Missing required property')), + beanshooter: (json.containsKey("beanshooter") ? json["beanshooter"] : throw FormatException('Missing required property')), + bearhound: (json.containsKey("bearhound") ? json["bearhound"] : throw FormatException('Missing required property')), + cayuga: (json.containsKey("Cayuga") ? json["Cayuga"] : throw FormatException('Missing required property')), + guarneri: (json.containsKey("guarneri") ? json["guarneri"] : throw FormatException('Missing required property')), + hypochondriacism: (json.containsKey("hypochondriacism") ? json["hypochondriacism"] : throw FormatException('Missing required property')), + indication: (json.containsKey("indication") ? json["indication"] : throw FormatException('Missing required property')), + jaculative: (json.containsKey("jaculative") ? json["jaculative"] : throw FormatException('Missing required property')), + nagana: (json.containsKey("nagana") ? json["nagana"] : throw FormatException('Missing required property')), + netherlandish: (json.containsKey("Netherlandish") ? json["Netherlandish"] : throw FormatException('Missing required property')), + noctivagous: (json.containsKey("noctivagous") ? json["noctivagous"] : throw FormatException('Missing required property')), + nonphysiological: (json.containsKey("nonphysiological") ? json["nonphysiological"] : throw FormatException('Missing required property')), + praxis: (json.containsKey("praxis") ? json["praxis"] : throw FormatException('Missing required property')), + provision: (json.containsKey("provision") ? json["provision"] : throw FormatException('Missing required property')), + subterhuman: (json.containsKey("subterhuman") ? json["subterhuman"] : throw FormatException('Missing required property')), + sunlit: (json.containsKey("sunlit") ? json["sunlit"] : throw FormatException('Missing required property')), + syncraniate: (json.containsKey("syncraniate") ? json["syncraniate"] : throw FormatException('Missing required property')), + teachment: (json.containsKey("teachment") ? json["teachment"] : throw FormatException('Missing required property')), + unmutinous: (json.containsKey("unmutinous") ? json["unmutinous"] : throw FormatException('Missing required property')), + unstoppable: (json.containsKey("unstoppable") ? json["unstoppable"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "Acrobates": acrobates, + "beanshooter": beanshooter, + "bearhound": bearhound, + "Cayuga": cayuga, + "guarneri": guarneri, + "hypochondriacism": hypochondriacism, + "indication": indication, + "jaculative": jaculative, + "nagana": nagana, + "Netherlandish": netherlandish, + "noctivagous": noctivagous, + "nonphysiological": nonphysiological, + "praxis": praxis, + "provision": provision, + "subterhuman": subterhuman, + "sunlit": sunlit, + "syncraniate": syncraniate, + "teachment": teachment, + "unmutinous": unmutinous, + "unstoppable": unstoppable, + }; +} diff --git a/head/dart/test/inputs/json/priority/combinations3.json/from-map-true--d222f65b3fee/TopLevel.dart b/head/dart/test/inputs/json/priority/combinations3.json/from-map-true--d222f65b3fee/TopLevel.dart new file mode 100644 index 0000000..ab644d5 --- /dev/null +++ b/head/dart/test/inputs/json/priority/combinations3.json/from-map-true--d222f65b3fee/TopLevel.dart @@ -0,0 +1,1537 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromMap(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toMap()); + +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.fromMap(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.fromMap(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.fromMap(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.fromMap(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.fromMap(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 toMap() => { + "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.toMap())), + "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?.toMap())), + "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.toMap())), + "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?.toMap())), + "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.fromMap(Map json) => JurorClass( + adipsy: (json.containsKey("adipsy") ? json["adipsy"] : throw FormatException('Missing required property')), + auxiliator: (json.containsKey("auxiliator") ? json["auxiliator"] : throw FormatException('Missing required property')), + benda: (json.containsKey("benda") ? json["benda"] : throw FormatException('Missing required property')), + benjamin: (json.containsKey("benjamin") ? json["benjamin"] : throw FormatException('Missing required property')), + brandling: (json.containsKey("brandling") ? json["brandling"] : throw FormatException('Missing required property')), + epicurishly: (json.containsKey("epicurishly") ? json["epicurishly"] : throw FormatException('Missing required property')), + eremochaetous: (json.containsKey("eremochaetous") ? json["eremochaetous"] : throw FormatException('Missing required property')), + marten: (json.containsKey("marten") ? json["marten"] : throw FormatException('Missing required property')), + monocline: (json.containsKey("monocline") ? json["monocline"] : throw FormatException('Missing required property')), + olea: (json.containsKey("Olea") ? json["Olea"] : throw FormatException('Missing required property')), + palgat: (json.containsKey("palgat") ? json["palgat"] : throw FormatException('Missing required property')), + pennyworth: (json.containsKey("pennyworth") ? json["pennyworth"] : throw FormatException('Missing required property')), + pioury: (json.containsKey("pioury") ? json["pioury"] : throw FormatException('Missing required property')), + pragmatistic: (json.containsKey("pragmatistic") ? json["pragmatistic"] : throw FormatException('Missing required property')), + stylelessness: (json.containsKey("stylelessness") ? json["stylelessness"] : throw FormatException('Missing required property')), + systematical: (json.containsKey("systematical") ? json["systematical"] : throw FormatException('Missing required property')), + thready: (json.containsKey("thready") ? json["thready"] : throw FormatException('Missing required property')), + uncontemporary: (json.containsKey("uncontemporary") ? json["uncontemporary"] : throw FormatException('Missing required property')), + uncouched: (json.containsKey("uncouched") ? json["uncouched"] : throw FormatException('Missing required property')), + uninhabitedness: (json.containsKey("uninhabitedness") ? json["uninhabitedness"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "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.fromMap(Map json) => LadronismClass( + acclaimer: (json.containsKey("acclaimer") ? json["acclaimer"] : throw FormatException('Missing required property')), + achree: (json.containsKey("achree") ? json["achree"] : throw FormatException('Missing required property')), + base: (json.containsKey("base") ? json["base"] : throw FormatException('Missing required property')), + conundrumize: (json.containsKey("conundrumize") ? json["conundrumize"] : throw FormatException('Missing required property')), + degerminator: (json.containsKey("degerminator") ? json["degerminator"] : throw FormatException('Missing required property')), + describable: (json.containsKey("describable") ? json["describable"] : throw FormatException('Missing required property')), + exasperatedly: (json.containsKey("exasperatedly") ? json["exasperatedly"] : throw FormatException('Missing required property')), + heroine: (json.containsKey("heroine") ? json["heroine"] : throw FormatException('Missing required property')), + indazin: (json.containsKey("indazin") ? json["indazin"] : throw FormatException('Missing required property')), + luteous: (json.containsKey("luteous") ? json["luteous"] : throw FormatException('Missing required property')), + papular: (json.containsKey("papular") ? json["papular"] : throw FormatException('Missing required property')), + pritch: (json.containsKey("pritch") ? json["pritch"] : throw FormatException('Missing required property')), + prodenia: (json.containsKey("Prodenia") ? json["Prodenia"] : throw FormatException('Missing required property')), + seege: (json.containsKey("seege") ? json["seege"] : throw FormatException('Missing required property')), + shopgirl: (json.containsKey("shopgirl") ? json["shopgirl"] : throw FormatException('Missing required property')), + tragedietta: (json.containsKey("tragedietta") ? json["tragedietta"] : throw FormatException('Missing required property')), + unsparse: (json.containsKey("unsparse") ? json["unsparse"] : throw FormatException('Missing required property')), + uplook: (json.containsKey("uplook") ? json["uplook"] : throw FormatException('Missing required property')), + vermiformis: (json.containsKey("vermiformis") ? json["vermiformis"] : throw FormatException('Missing required property')), + whafabout: (json.containsKey("whafabout") ? json["whafabout"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "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.fromMap(Map json) => LandlubberlyClass( + acropoleis: (json.containsKey("acropoleis") ? json["acropoleis"] : throw FormatException('Missing required property')), + aminate: (json.containsKey("aminate") ? json["aminate"] : throw FormatException('Missing required property')), + amyraldism: (json.containsKey("Amyraldism") ? json["Amyraldism"] : throw FormatException('Missing required property')), + bipenniform: (json.containsKey("bipenniform") ? json["bipenniform"] : throw FormatException('Missing required property')), + bugre: (json.containsKey("bugre") ? json["bugre"] : throw FormatException('Missing required property')), + calycule: (json.containsKey("calycule") ? json["calycule"] : throw FormatException('Missing required property')), + caoutchouc: (json.containsKey("caoutchouc") ? json["caoutchouc"] : throw FormatException('Missing required property')), + disprover: (json.containsKey("disprover") ? json["disprover"] : throw FormatException('Missing required property')), + fitroot: (json.containsKey("fitroot") ? json["fitroot"] : throw FormatException('Missing required property')), + fulgently: (json.containsKey("fulgently") ? json["fulgently"] : throw FormatException('Missing required property')), + kickup: (json.containsKey("kickup") ? json["kickup"] : throw FormatException('Missing required property')), + laevoversion: (json.containsKey("laevoversion") ? json["laevoversion"] : throw FormatException('Missing required property')), + moter: (json.containsKey("moter") ? json["moter"] : throw FormatException('Missing required property')), + objectivity: (json.containsKey("objectivity") ? json["objectivity"] : throw FormatException('Missing required property')), + posterity: (json.containsKey("posterity") ? json["posterity"] : throw FormatException('Missing required property')), + postnuptial: (json.containsKey("postnuptial") ? json["postnuptial"] : throw FormatException('Missing required property')), + precedentary: (json.containsKey("precedentary") ? json["precedentary"] : throw FormatException('Missing required property')), + saddling: (json.containsKey("saddling") ? json["saddling"] : throw FormatException('Missing required property')), + subcurrent: (json.containsKey("subcurrent") ? json["subcurrent"] : throw FormatException('Missing required property')), + unrecriminative: (json.containsKey("unrecriminative") ? json["unrecriminative"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "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.fromMap(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 toMap() => { + "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.fromMap(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 toMap() => { + "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.fromMap(Map json) => MonaziteClass( + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + homocerc: json["homocerc"], + nonbookish: (json.containsKey("nonbookish") ? json["nonbookish"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "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.fromMap(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 toMap() => { + "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.fromMap(Map json) => Noncontributing( + estevin: json["estevin"], + jolterhead: json["jolterhead"]?.toDouble(), + sauternes: json["sauternes"], + sparsely: json["sparsely"], + unrequested: (json.containsKey("unrequested") ? json["unrequested"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "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.fromMap(Map json) => OccupationalistClass( + beholdable: (json.containsKey("beholdable") ? json["beholdable"] : throw FormatException('Missing required property')), + brotuliform: (json.containsKey("brotuliform") ? json["brotuliform"] : throw FormatException('Missing required property')), + chimakum: (json.containsKey("Chimakum") ? json["Chimakum"] : throw FormatException('Missing required property')), + doodler: (json.containsKey("doodler") ? json["doodler"] : throw FormatException('Missing required property')), + emulsin: (json.containsKey("emulsin") ? json["emulsin"] : throw FormatException('Missing required property')), + fin: (json.containsKey("Fin") ? json["Fin"] : throw FormatException('Missing required property')), + flourishing: (json.containsKey("flourishing") ? json["flourishing"] : throw FormatException('Missing required property')), + flueless: (json.containsKey("flueless") ? json["flueless"] : throw FormatException('Missing required property')), + furtively: (json.containsKey("furtively") ? json["furtively"] : throw FormatException('Missing required property')), + gritter: (json.containsKey("gritter") ? json["gritter"] : throw FormatException('Missing required property')), + interwish: (json.containsKey("interwish") ? json["interwish"] : throw FormatException('Missing required property')), + monoxylic: (json.containsKey("monoxylic") ? json["monoxylic"] : throw FormatException('Missing required property')), + myristic: (json.containsKey("myristic") ? json["myristic"] : throw FormatException('Missing required property')), + nightwear: (json.containsKey("nightwear") ? json["nightwear"] : throw FormatException('Missing required property')), + peruser: (json.containsKey("peruser") ? json["peruser"] : throw FormatException('Missing required property')), + theoastrological: (json.containsKey("theoastrological") ? json["theoastrological"] : throw FormatException('Missing required property')), + thumby: (json.containsKey("thumby") ? json["thumby"] : throw FormatException('Missing required property')), + tingitid: (json.containsKey("tingitid") ? json["tingitid"] : throw FormatException('Missing required property')), + trailless: (json.containsKey("trailless") ? json["trailless"] : throw FormatException('Missing required property')), + unpocketed: (json.containsKey("unpocketed") ? json["unpocketed"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "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.fromMap(Map json) => OutrivalClass( + adroitly: (json.containsKey("adroitly") ? json["adroitly"] : throw FormatException('Missing required property')), + bridehood: (json.containsKey("bridehood") ? json["bridehood"] : throw FormatException('Missing required property')), + castoroides: (json.containsKey("Castoroides") ? json["Castoroides"] : throw FormatException('Missing required property')), + czechoslovak: (json.containsKey("Czechoslovak") ? json["Czechoslovak"] : throw FormatException('Missing required property')), + diagenesis: (json.containsKey("diagenesis") ? json["diagenesis"] : throw FormatException('Missing required property')), + dihexahedron: (json.containsKey("dihexahedron") ? json["dihexahedron"] : throw FormatException('Missing required property')), + dopester: (json.containsKey("dopester") ? json["dopester"] : throw FormatException('Missing required property')), + eumerism: (json.containsKey("eumerism") ? json["eumerism"] : throw FormatException('Missing required property')), + flyness: (json.containsKey("flyness") ? json["flyness"] : throw FormatException('Missing required property')), + fouler: (json.containsKey("fouler") ? json["fouler"] : throw FormatException('Missing required property')), + laudanosine: (json.containsKey("laudanosine") ? json["laudanosine"] : throw FormatException('Missing required property')), + lingulidae: (json.containsKey("Lingulidae") ? json["Lingulidae"] : throw FormatException('Missing required property')), + minutary: (json.containsKey("minutary") ? json["minutary"] : throw FormatException('Missing required property')), + mitra: (json.containsKey("mitra") ? json["mitra"] : throw FormatException('Missing required property')), + opisthorchiasis: (json.containsKey("opisthorchiasis") ? json["opisthorchiasis"] : throw FormatException('Missing required property')), + pensively: (json.containsKey("pensively") ? json["pensively"] : throw FormatException('Missing required property')), + pubigerous: (json.containsKey("pubigerous") ? json["pubigerous"] : throw FormatException('Missing required property')), + rebellious: (json.containsKey("rebellious") ? json["rebellious"] : throw FormatException('Missing required property')), + recodify: (json.containsKey("recodify") ? json["recodify"] : throw FormatException('Missing required property')), + unpaced: (json.containsKey("unpaced") ? json["unpaced"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "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.fromMap(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 toMap() => { + "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.fromMap(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 toMap() => { + "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.fromMap(Map json) => PotwhiskyClass( + arciform: (json.containsKey("arciform") ? json["arciform"] : throw FormatException('Missing required property')), + cresolin: (json.containsKey("cresolin") ? json["cresolin"] : throw FormatException('Missing required property')), + disheartener: (json.containsKey("disheartener") ? json["disheartener"] : throw FormatException('Missing required property')), + disproportionable: (json.containsKey("disproportionable") ? json["disproportionable"] : throw FormatException('Missing required property')), + euchorda: (json.containsKey("Euchorda") ? json["Euchorda"] : throw FormatException('Missing required property')), + ferryway: (json.containsKey("ferryway") ? json["ferryway"] : throw FormatException('Missing required property')), + filamentiferous: (json.containsKey("filamentiferous") ? json["filamentiferous"] : throw FormatException('Missing required property')), + flemish: (json.containsKey("flemish") ? json["flemish"] : throw FormatException('Missing required property')), + forgainst: (json.containsKey("forgainst") ? json["forgainst"] : throw FormatException('Missing required property')), + grainering: (json.containsKey("grainering") ? json["grainering"] : throw FormatException('Missing required property')), + irrevoluble: (json.containsKey("irrevoluble") ? json["irrevoluble"] : throw FormatException('Missing required property')), + kindredship: (json.containsKey("kindredship") ? json["kindredship"] : throw FormatException('Missing required property')), + pinguitudinous: (json.containsKey("pinguitudinous") ? json["pinguitudinous"] : throw FormatException('Missing required property')), + simpletonic: (json.containsKey("simpletonic") ? json["simpletonic"] : throw FormatException('Missing required property')), + singsong: (json.containsKey("singsong") ? json["singsong"] : throw FormatException('Missing required property')), + submergement: (json.containsKey("submergement") ? json["submergement"] : throw FormatException('Missing required property')), + supraoesophagal: (json.containsKey("supraoesophagal") ? json["supraoesophagal"] : throw FormatException('Missing required property')), + thrashel: (json.containsKey("thrashel") ? json["thrashel"] : throw FormatException('Missing required property')), + tyremesis: (json.containsKey("tyremesis") ? json["tyremesis"] : throw FormatException('Missing required property')), + yoruba: (json.containsKey("Yoruba") ? json["Yoruba"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "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.fromMap(Map json) => PrefreshmanClass( + azorubine: (json.containsKey("azorubine") ? json["azorubine"] : throw FormatException('Missing required property')), + choroiditis: (json.containsKey("choroiditis") ? json["choroiditis"] : throw FormatException('Missing required property')), + coagulatory: (json.containsKey("coagulatory") ? json["coagulatory"] : throw FormatException('Missing required property')), + cyclorama: (json.containsKey("cyclorama") ? json["cyclorama"] : throw FormatException('Missing required property')), + dolphus: (json.containsKey("Dolphus") ? json["Dolphus"] : throw FormatException('Missing required property')), + duckhearted: (json.containsKey("duckhearted") ? json["duckhearted"] : throw FormatException('Missing required property')), + ficus: (json.containsKey("Ficus") ? json["Ficus"] : throw FormatException('Missing required property')), + gemaric: (json.containsKey("Gemaric") ? json["Gemaric"] : throw FormatException('Missing required property')), + jugation: (json.containsKey("jugation") ? json["jugation"] : throw FormatException('Missing required property')), + myoliposis: (json.containsKey("myoliposis") ? json["myoliposis"] : throw FormatException('Missing required property')), + nonnomination: (json.containsKey("nonnomination") ? json["nonnomination"] : throw FormatException('Missing required property')), + palay: (json.containsKey("palay") ? json["palay"] : throw FormatException('Missing required property')), + pentactinal: (json.containsKey("pentactinal") ? json["pentactinal"] : throw FormatException('Missing required property')), + phaet: (json.containsKey("Phaet") ? json["Phaet"] : throw FormatException('Missing required property')), + piquant: (json.containsKey("piquant") ? json["piquant"] : throw FormatException('Missing required property')), + registration: (json.containsKey("registration") ? json["registration"] : throw FormatException('Missing required property')), + remancipation: (json.containsKey("remancipation") ? json["remancipation"] : throw FormatException('Missing required property')), + scutatiform: (json.containsKey("scutatiform") ? json["scutatiform"] : throw FormatException('Missing required property')), + theodolite: (json.containsKey("theodolite") ? json["theodolite"] : throw FormatException('Missing required property')), + underward: (json.containsKey("underward") ? json["underward"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "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/from-map-true--d222f65b3fee/TopLevel.dart b/head/dart/test/inputs/json/priority/combinations4.json/from-map-true--d222f65b3fee/TopLevel.dart new file mode 100644 index 0000000..8564d49 --- /dev/null +++ b/head/dart/test/inputs/json/priority/combinations4.json/from-map-true--d222f65b3fee/TopLevel.dart @@ -0,0 +1,1761 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromMap(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toMap()); + +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.fromMap(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.fromMap(x))), + ressaut: Ressaut.fromMap(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.fromMap(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.fromMap(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 toMap() => { + "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.toMap())), + "ressaut": ressaut.toMap(), + "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?.toMap())), + "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.toMap())), + "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.fromMap(Map json) => PulpitismClass( + abnet: (json.containsKey("abnet") ? json["abnet"] : throw FormatException('Missing required property')), + buckhorn: (json.containsKey("buckhorn") ? json["buckhorn"] : throw FormatException('Missing required property')), + calciform: (json.containsKey("calciform") ? json["calciform"] : throw FormatException('Missing required property')), + chelophore: (json.containsKey("chelophore") ? json["chelophore"] : throw FormatException('Missing required property')), + cogitation: (json.containsKey("cogitation") ? json["cogitation"] : throw FormatException('Missing required property')), + decreeable: (json.containsKey("decreeable") ? json["decreeable"] : throw FormatException('Missing required property')), + despicable: (json.containsKey("despicable") ? json["despicable"] : throw FormatException('Missing required property')), + isodiazo: (json.containsKey("isodiazo") ? json["isodiazo"] : throw FormatException('Missing required property')), + jadedly: (json.containsKey("jadedly") ? json["jadedly"] : throw FormatException('Missing required property')), + leptochlorite: (json.containsKey("leptochlorite") ? json["leptochlorite"] : throw FormatException('Missing required property')), + nursling: (json.containsKey("nursling") ? json["nursling"] : throw FormatException('Missing required property')), + palamedean: (json.containsKey("palamedean") ? json["palamedean"] : throw FormatException('Missing required property')), + photoheliograph: (json.containsKey("photoheliograph") ? json["photoheliograph"] : throw FormatException('Missing required property')), + pipewood: (json.containsKey("pipewood") ? json["pipewood"] : throw FormatException('Missing required property')), + roberd: (json.containsKey("roberd") ? json["roberd"] : throw FormatException('Missing required property')), + statable: (json.containsKey("statable") ? json["statable"] : throw FormatException('Missing required property')), + superassume: (json.containsKey("superassume") ? json["superassume"] : throw FormatException('Missing required property')), + syllabe: (json.containsKey("syllabe") ? json["syllabe"] : throw FormatException('Missing required property')), + toughhead: (json.containsKey("toughhead") ? json["toughhead"] : throw FormatException('Missing required property')), + underburn: (json.containsKey("underburn") ? json["underburn"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "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.fromMap(Map json) => PyodermiaClass( + aphoristically: (json.containsKey("aphoristically") ? json["aphoristically"] : throw FormatException('Missing required property')), + apophyllous: (json.containsKey("apophyllous") ? json["apophyllous"] : throw FormatException('Missing required property')), + cognize: (json.containsKey("cognize") ? json["cognize"] : throw FormatException('Missing required property')), + dermonosology: (json.containsKey("dermonosology") ? json["dermonosology"] : throw FormatException('Missing required property')), + gyppo: (json.containsKey("Gyppo") ? json["Gyppo"] : throw FormatException('Missing required property')), + ither: (json.containsKey("ither") ? json["ither"] : throw FormatException('Missing required property')), + juglandaceous: (json.containsKey("juglandaceous") ? json["juglandaceous"] : throw FormatException('Missing required property')), + litho: (json.containsKey("litho") ? json["litho"] : throw FormatException('Missing required property')), + macropterous: (json.containsKey("macropterous") ? json["macropterous"] : throw FormatException('Missing required property')), + photographer: (json.containsKey("photographer") ? json["photographer"] : throw FormatException('Missing required property')), + romancing: (json.containsKey("romancing") ? json["romancing"] : throw FormatException('Missing required property')), + rumness: (json.containsKey("rumness") ? json["rumness"] : throw FormatException('Missing required property')), + somniloquist: (json.containsKey("somniloquist") ? json["somniloquist"] : throw FormatException('Missing required property')), + stressfully: (json.containsKey("stressfully") ? json["stressfully"] : throw FormatException('Missing required property')), + tactically: (json.containsKey("tactically") ? json["tactically"] : throw FormatException('Missing required property')), + tracheophony: (json.containsKey("tracheophony") ? json["tracheophony"] : throw FormatException('Missing required property')), + unappositely: (json.containsKey("unappositely") ? json["unappositely"] : throw FormatException('Missing required property')), + unclothedly: (json.containsKey("unclothedly") ? json["unclothedly"] : throw FormatException('Missing required property')), + unimplied: (json.containsKey("unimplied") ? json["unimplied"] : throw FormatException('Missing required property')), + unsyncopated: (json.containsKey("unsyncopated") ? json["unsyncopated"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "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.fromMap(Map json) => QuebrachineClass( + catharticalness: json["catharticalness"]?.toDouble(), + chirotherium: json["Chirotherium"], + disdiapason: json["disdiapason"], + homocerc: json["homocerc"], + nonbookish: (json.containsKey("nonbookish") ? json["nonbookish"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "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.fromMap(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 toMap() => { + "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.fromMap(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 toMap() => { + "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.fromMap(Map json) => RewriteClass( + accountancy: (json.containsKey("accountancy") ? json["accountancy"] : throw FormatException('Missing required property')), + cacotrophic: (json.containsKey("cacotrophic") ? json["cacotrophic"] : throw FormatException('Missing required property')), + contest: (json.containsKey("contest") ? json["contest"] : throw FormatException('Missing required property')), + couthily: (json.containsKey("couthily") ? json["couthily"] : throw FormatException('Missing required property')), + falculate: (json.containsKey("falculate") ? json["falculate"] : throw FormatException('Missing required property')), + foreseize: (json.containsKey("foreseize") ? json["foreseize"] : throw FormatException('Missing required property')), + hyades: (json.containsKey("Hyades") ? json["Hyades"] : throw FormatException('Missing required property')), + lemnad: (json.containsKey("lemnad") ? json["lemnad"] : throw FormatException('Missing required property')), + monotheistically: (json.containsKey("monotheistically") ? json["monotheistically"] : throw FormatException('Missing required property')), + nonflying: (json.containsKey("nonflying") ? json["nonflying"] : throw FormatException('Missing required property')), + ptenoglossa: (json.containsKey("Ptenoglossa") ? json["Ptenoglossa"] : throw FormatException('Missing required property')), + repatch: (json.containsKey("repatch") ? json["repatch"] : throw FormatException('Missing required property')), + rodman: (json.containsKey("rodman") ? json["rodman"] : throw FormatException('Missing required property')), + strung: (json.containsKey("strung") ? json["strung"] : throw FormatException('Missing required property')), + titmal: (json.containsKey("titmal") ? json["titmal"] : throw FormatException('Missing required property')), + twalpennyworth: (json.containsKey("twalpennyworth") ? json["twalpennyworth"] : throw FormatException('Missing required property')), + unblamable: (json.containsKey("unblamable") ? json["unblamable"] : throw FormatException('Missing required property')), + vertical: (json.containsKey("vertical") ? json["vertical"] : throw FormatException('Missing required property')), + whiggification: (json.containsKey("Whiggification") ? json["Whiggification"] : throw FormatException('Missing required property')), + yardman: (json.containsKey("yardman") ? json["yardman"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "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.fromMap(Map json) => SantirClass( + admiredly: (json.containsKey("admiredly") ? json["admiredly"] : throw FormatException('Missing required property')), + demicaponier: (json.containsKey("demicaponier") ? json["demicaponier"] : throw FormatException('Missing required property')), + epitympanic: (json.containsKey("epitympanic") ? json["epitympanic"] : throw FormatException('Missing required property')), + investitor: (json.containsKey("investitor") ? json["investitor"] : throw FormatException('Missing required property')), + lupiform: (json.containsKey("lupiform") ? json["lupiform"] : throw FormatException('Missing required property')), + monoflagellate: (json.containsKey("monoflagellate") ? json["monoflagellate"] : throw FormatException('Missing required property')), + paleoethnic: (json.containsKey("paleoethnic") ? json["paleoethnic"] : throw FormatException('Missing required property')), + prediscountable: (json.containsKey("prediscountable") ? json["prediscountable"] : throw FormatException('Missing required property')), + rhetoricals: (json.containsKey("rhetoricals") ? json["rhetoricals"] : throw FormatException('Missing required property')), + roomth: (json.containsKey("roomth") ? json["roomth"] : throw FormatException('Missing required property')), + saccharose: (json.containsKey("saccharose") ? json["saccharose"] : throw FormatException('Missing required property')), + septonasal: (json.containsKey("septonasal") ? json["septonasal"] : throw FormatException('Missing required property')), + serpenticide: (json.containsKey("serpenticide") ? json["serpenticide"] : throw FormatException('Missing required property')), + setarious: (json.containsKey("setarious") ? json["setarious"] : throw FormatException('Missing required property')), + spaework: (json.containsKey("spaework") ? json["spaework"] : throw FormatException('Missing required property')), + stylite: (json.containsKey("stylite") ? json["stylite"] : throw FormatException('Missing required property')), + suessiones: (json.containsKey("Suessiones") ? json["Suessiones"] : throw FormatException('Missing required property')), + timelily: (json.containsKey("timelily") ? json["timelily"] : throw FormatException('Missing required property')), + unprofaned: (json.containsKey("unprofaned") ? json["unprofaned"] : throw FormatException('Missing required property')), + vorticular: (json.containsKey("vorticular") ? json["vorticular"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "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.fromMap(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 toMap() => { + "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.fromMap(Map json) => Scatty( + aeriferous: (json.containsKey("aeriferous") ? json["aeriferous"] : throw FormatException('Missing required property')), + antical: (json.containsKey("antical") ? json["antical"] : throw FormatException('Missing required property')), + antighostism: (json.containsKey("antighostism") ? json["antighostism"] : throw FormatException('Missing required property')), + arcanum: (json.containsKey("arcanum") ? json["arcanum"] : throw FormatException('Missing required property')), + autotrophy: (json.containsKey("autotrophy") ? json["autotrophy"] : throw FormatException('Missing required property')), + baronial: (json.containsKey("baronial") ? json["baronial"] : throw FormatException('Missing required property')), + caffeine: (json.containsKey("caffeine") ? json["caffeine"] : throw FormatException('Missing required property')), + gorgoniacean: (json.containsKey("gorgoniacean") ? json["gorgoniacean"] : throw FormatException('Missing required property')), + heroical: (json.containsKey("heroical") ? json["heroical"] : throw FormatException('Missing required property')), + hydropical: (json.containsKey("hydropical") ? json["hydropical"] : throw FormatException('Missing required property')), + mechanology: (json.containsKey("mechanology") ? json["mechanology"] : throw FormatException('Missing required property')), + musicopoetic: (json.containsKey("musicopoetic") ? json["musicopoetic"] : throw FormatException('Missing required property')), + officiality: (json.containsKey("officiality") ? json["officiality"] : throw FormatException('Missing required property')), + oftentimes: (json.containsKey("oftentimes") ? json["oftentimes"] : throw FormatException('Missing required property')), + ophthalmotonometer: (json.containsKey("ophthalmotonometer") ? json["ophthalmotonometer"] : throw FormatException('Missing required property')), + reflectively: (json.containsKey("reflectively") ? json["reflectively"] : throw FormatException('Missing required property')), + springer: (json.containsKey("springer") ? json["springer"] : throw FormatException('Missing required property')), + tabasco: (json.containsKey("Tabasco") ? json["Tabasco"] : throw FormatException('Missing required property')), + teleianthous: (json.containsKey("teleianthous") ? json["teleianthous"] : throw FormatException('Missing required property')), + uncombated: (json.containsKey("uncombated") ? json["uncombated"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "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.fromMap(Map json) => SisteringClass( + amphicarpic: (json.containsKey("amphicarpic") ? json["amphicarpic"] : throw FormatException('Missing required property')), + chianti: (json.containsKey("Chianti") ? json["Chianti"] : throw FormatException('Missing required property')), + frigorific: (json.containsKey("frigorific") ? json["frigorific"] : throw FormatException('Missing required property')), + haplomi: (json.containsKey("Haplomi") ? json["Haplomi"] : throw FormatException('Missing required property')), + hyperkinesis: (json.containsKey("hyperkinesis") ? json["hyperkinesis"] : throw FormatException('Missing required property')), + laudable: (json.containsKey("laudable") ? json["laudable"] : throw FormatException('Missing required property')), + madwoman: (json.containsKey("madwoman") ? json["madwoman"] : throw FormatException('Missing required property')), + maimedly: (json.containsKey("maimedly") ? json["maimedly"] : throw FormatException('Missing required property')), + micropterygidae: (json.containsKey("Micropterygidae") ? json["Micropterygidae"] : throw FormatException('Missing required property')), + microrhabdus: (json.containsKey("microrhabdus") ? json["microrhabdus"] : throw FormatException('Missing required property')), + nondense: (json.containsKey("nondense") ? json["nondense"] : throw FormatException('Missing required property')), + phlebemphraxis: (json.containsKey("phlebemphraxis") ? json["phlebemphraxis"] : throw FormatException('Missing required property')), + redsear: (json.containsKey("redsear") ? json["redsear"] : throw FormatException('Missing required property')), + schismatical: (json.containsKey("schismatical") ? json["schismatical"] : throw FormatException('Missing required property')), + tartryl: (json.containsKey("tartryl") ? json["tartryl"] : throw FormatException('Missing required property')), + unabhorred: (json.containsKey("unabhorred") ? json["unabhorred"] : throw FormatException('Missing required property')), + undeliberateness: (json.containsKey("undeliberateness") ? json["undeliberateness"] : throw FormatException('Missing required property')), + unmixable: (json.containsKey("unmixable") ? json["unmixable"] : throw FormatException('Missing required property')), + untruckling: (json.containsKey("untruckling") ? json["untruckling"] : throw FormatException('Missing required property')), + vineal: (json.containsKey("vineal") ? json["vineal"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "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.fromMap(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 toMap() => { + "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.fromMap(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 toMap() => { + "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.fromMap(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 toMap() => { + "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.fromMap(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 toMap() => { + "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.fromMap(Map json) => UnstressedClass( + alain: (json.containsKey("Alain") ? json["Alain"] : throw FormatException('Missing required property')), + amphirhina: (json.containsKey("Amphirhina") ? json["Amphirhina"] : throw FormatException('Missing required property')), + antimachinery: (json.containsKey("antimachinery") ? json["antimachinery"] : throw FormatException('Missing required property')), + coldish: (json.containsKey("coldish") ? json["coldish"] : throw FormatException('Missing required property')), + crantara: (json.containsKey("crantara") ? json["crantara"] : throw FormatException('Missing required property')), + distinguishing: (json.containsKey("distinguishing") ? json["distinguishing"] : throw FormatException('Missing required property')), + elytroposis: (json.containsKey("elytroposis") ? json["elytroposis"] : throw FormatException('Missing required property')), + gentianwort: (json.containsKey("gentianwort") ? json["gentianwort"] : throw FormatException('Missing required property')), + heliosis: (json.containsKey("heliosis") ? json["heliosis"] : throw FormatException('Missing required property')), + instrumental: (json.containsKey("instrumental") ? json["instrumental"] : throw FormatException('Missing required property')), + introinflection: (json.containsKey("introinflection") ? json["introinflection"] : throw FormatException('Missing required property')), + kala: (json.containsKey("kala") ? json["kala"] : throw FormatException('Missing required property')), + lincolnian: (json.containsKey("Lincolnian") ? json["Lincolnian"] : throw FormatException('Missing required property')), + metad: (json.containsKey("metad") ? json["metad"] : throw FormatException('Missing required property')), + sarcophilus: (json.containsKey("Sarcophilus") ? json["Sarcophilus"] : throw FormatException('Missing required property')), + swingingly: (json.containsKey("swingingly") ? json["swingingly"] : throw FormatException('Missing required property')), + unconformity: (json.containsKey("unconformity") ? json["unconformity"] : throw FormatException('Missing required property')), + undecreed: (json.containsKey("undecreed") ? json["undecreed"] : throw FormatException('Missing required property')), + venerable: (json.containsKey("venerable") ? json["venerable"] : throw FormatException('Missing required property')), + vowellessness: (json.containsKey("vowellessness") ? json["vowellessness"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "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.fromMap(Map json) => WrothyClass( + aeschynanthus: (json.containsKey("Aeschynanthus") ? json["Aeschynanthus"] : throw FormatException('Missing required property')), + aquiferous: (json.containsKey("aquiferous") ? json["aquiferous"] : throw FormatException('Missing required property')), + cheapener: (json.containsKey("cheapener") ? json["cheapener"] : throw FormatException('Missing required property')), + enumeration: (json.containsKey("enumeration") ? json["enumeration"] : throw FormatException('Missing required property')), + ephesine: (json.containsKey("Ephesine") ? json["Ephesine"] : throw FormatException('Missing required property')), + escadrille: (json.containsKey("escadrille") ? json["escadrille"] : throw FormatException('Missing required property')), + estrous: (json.containsKey("estrous") ? json["estrous"] : throw FormatException('Missing required property')), + interestedly: (json.containsKey("interestedly") ? json["interestedly"] : throw FormatException('Missing required property')), + katakinetomer: (json.containsKey("katakinetomer") ? json["katakinetomer"] : throw FormatException('Missing required property')), + mortification: (json.containsKey("mortification") ? json["mortification"] : throw FormatException('Missing required property')), + morula: (json.containsKey("morula") ? json["morula"] : throw FormatException('Missing required property')), + orthosymmetrical: (json.containsKey("orthosymmetrical") ? json["orthosymmetrical"] : throw FormatException('Missing required property')), + overbark: (json.containsKey("overbark") ? json["overbark"] : throw FormatException('Missing required property')), + politist: (json.containsKey("politist") ? json["politist"] : throw FormatException('Missing required property')), + qualified: (json.containsKey("qualified") ? json["qualified"] : throw FormatException('Missing required property')), + sphenomalar: (json.containsKey("sphenomalar") ? json["sphenomalar"] : throw FormatException('Missing required property')), + throatful: (json.containsKey("throatful") ? json["throatful"] : throw FormatException('Missing required property')), + transhumance: (json.containsKey("transhumance") ? json["transhumance"] : throw FormatException('Missing required property')), + triandrian: (json.containsKey("triandrian") ? json["triandrian"] : throw FormatException('Missing required property')), + unbooked: (json.containsKey("unbooked") ? json["unbooked"] : throw FormatException('Missing required property')), + ); + + Map toMap() => { + "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/base/flow/test/inputs/json/misc/00c36.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/00c36.json/default/TopLevel.js index 028c89f..cc42d8f 100644 --- a/base/flow/test/inputs/json/misc/00c36.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/00c36.json/default/TopLevel.js @@ -163,7 +163,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/00ec5.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/00ec5.json/default/TopLevel.js index 46b5ac1..ddeecd4 100644 --- a/base/flow/test/inputs/json/misc/00ec5.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/00ec5.json/default/TopLevel.js @@ -202,7 +202,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/010b1.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/010b1.json/default/TopLevel.js index 666804a..f84af0d 100644 --- a/base/flow/test/inputs/json/misc/010b1.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/010b1.json/default/TopLevel.js @@ -145,7 +145,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/016af.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/016af.json/default/TopLevel.js index c2c007d..cbe621d 100644 --- a/base/flow/test/inputs/json/misc/016af.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/016af.json/default/TopLevel.js @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/033b1.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/033b1.json/default/TopLevel.js index 2ae4813..5fa36d1 100644 --- a/base/flow/test/inputs/json/misc/033b1.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/033b1.json/default/TopLevel.js @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/050b0.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/050b0.json/default/TopLevel.js index f489629..5250513 100644 --- a/base/flow/test/inputs/json/misc/050b0.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/050b0.json/default/TopLevel.js @@ -191,7 +191,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/06bee.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/06bee.json/default/TopLevel.js index bce87ba..c5932fd 100644 --- a/base/flow/test/inputs/json/misc/06bee.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/06bee.json/default/TopLevel.js @@ -179,7 +179,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/07540.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/07540.json/default/TopLevel.js index c1848de..e699d4e 100644 --- a/base/flow/test/inputs/json/misc/07540.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/07540.json/default/TopLevel.js @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/0779f.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/0779f.json/default/TopLevel.js index a07dba1..3d06c27 100644 --- a/base/flow/test/inputs/json/misc/0779f.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/0779f.json/default/TopLevel.js @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/07c75.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/07c75.json/default/TopLevel.js index 2745288..925106b 100644 --- a/base/flow/test/inputs/json/misc/07c75.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/07c75.json/default/TopLevel.js @@ -160,7 +160,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/09f54.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/09f54.json/default/TopLevel.js index ddea840..cdfaa32 100644 --- a/base/flow/test/inputs/json/misc/09f54.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/09f54.json/default/TopLevel.js @@ -148,7 +148,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/0a358.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/0a358.json/default/TopLevel.js index 02334fc..50e1b2a 100644 --- a/base/flow/test/inputs/json/misc/0a358.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/0a358.json/default/TopLevel.js @@ -153,7 +153,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/0a91a.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/0a91a.json/default/TopLevel.js index f6c0b9c..cbb73dd 100644 --- a/base/flow/test/inputs/json/misc/0a91a.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/0a91a.json/default/TopLevel.js @@ -355,7 +355,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/0b91a.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/0b91a.json/default/TopLevel.js index 0cc6b18..a055871 100644 --- a/base/flow/test/inputs/json/misc/0b91a.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/0b91a.json/default/TopLevel.js @@ -176,7 +176,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (typeof typ === "object") { return typ.hasOwnProperty("uuid") ? typeof val === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(val) ? val : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/0cffa.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/0cffa.json/default/TopLevel.js index e30bd60..7e8c132 100644 --- a/base/flow/test/inputs/json/misc/0cffa.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/0cffa.json/default/TopLevel.js @@ -250,7 +250,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/0e0c2.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/0e0c2.json/default/TopLevel.js index d529089..17fd377 100644 --- a/base/flow/test/inputs/json/misc/0e0c2.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/0e0c2.json/default/TopLevel.js @@ -212,7 +212,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/0fecf.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/0fecf.json/default/TopLevel.js index 9686fae..3c46850 100644 --- a/base/flow/test/inputs/json/misc/0fecf.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/0fecf.json/default/TopLevel.js @@ -135,7 +135,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/10be4.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/10be4.json/default/TopLevel.js index 1fc02c1..22a5277 100644 --- a/base/flow/test/inputs/json/misc/10be4.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/10be4.json/default/TopLevel.js @@ -202,7 +202,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/112b5.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/112b5.json/default/TopLevel.js index 2611898..6e0d3c1 100644 --- a/base/flow/test/inputs/json/misc/112b5.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/112b5.json/default/TopLevel.js @@ -148,7 +148,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/127a1.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/127a1.json/default/TopLevel.js index 40d267f..199064c 100644 --- a/base/flow/test/inputs/json/misc/127a1.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/127a1.json/default/TopLevel.js @@ -249,7 +249,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/13d8d.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/13d8d.json/default/TopLevel.js index 991c5fc..e03ad53 100644 --- a/base/flow/test/inputs/json/misc/13d8d.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/13d8d.json/default/TopLevel.js @@ -161,7 +161,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/14d38.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/14d38.json/default/TopLevel.js index bec0f25..0b913fa 100644 --- a/base/flow/test/inputs/json/misc/14d38.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/14d38.json/default/TopLevel.js @@ -142,7 +142,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/167d6.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/167d6.json/default/TopLevel.js index 2ae4813..5fa36d1 100644 --- a/base/flow/test/inputs/json/misc/167d6.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/167d6.json/default/TopLevel.js @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/16bc5.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/16bc5.json/default/TopLevel.js index 704d101..e5480dc 100644 --- a/base/flow/test/inputs/json/misc/16bc5.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/16bc5.json/default/TopLevel.js @@ -233,7 +233,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/176f1.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/176f1.json/default/TopLevel.js index 8311c33..7fdf613 100644 --- a/base/flow/test/inputs/json/misc/176f1.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/176f1.json/default/TopLevel.js @@ -160,7 +160,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/1a7f5.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/1a7f5.json/default/TopLevel.js index 666804a..f84af0d 100644 --- a/base/flow/test/inputs/json/misc/1a7f5.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/1a7f5.json/default/TopLevel.js @@ -145,7 +145,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/1b28c.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/1b28c.json/default/TopLevel.js index c2c007d..cbe621d 100644 --- a/base/flow/test/inputs/json/misc/1b28c.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/1b28c.json/default/TopLevel.js @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/1b409.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/1b409.json/default/TopLevel.js index b6437cb..bec5637 100644 --- a/base/flow/test/inputs/json/misc/1b409.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/1b409.json/default/TopLevel.js @@ -226,7 +226,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/2465e.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/2465e.json/default/TopLevel.js index 6701758..b7df128 100644 --- a/base/flow/test/inputs/json/misc/2465e.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/2465e.json/default/TopLevel.js @@ -208,7 +208,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/24f52.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/24f52.json/default/TopLevel.js index a07dba1..3d06c27 100644 --- a/base/flow/test/inputs/json/misc/24f52.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/24f52.json/default/TopLevel.js @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/262f0.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/262f0.json/default/TopLevel.js index 4aa41ba..3730989 100644 --- a/base/flow/test/inputs/json/misc/262f0.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/262f0.json/default/TopLevel.js @@ -238,7 +238,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/26b49.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/26b49.json/default/TopLevel.js index 2fb7a69..33af2f1 100644 --- a/base/flow/test/inputs/json/misc/26b49.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/26b49.json/default/TopLevel.js @@ -247,7 +247,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/26c9c.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/26c9c.json/default/TopLevel.js index 91e9a2f..d5ee5ad 100644 --- a/base/flow/test/inputs/json/misc/26c9c.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/26c9c.json/default/TopLevel.js @@ -322,7 +322,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/27332.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/27332.json/default/TopLevel.js index 30017ad..504c0e4 100644 --- a/base/flow/test/inputs/json/misc/27332.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/27332.json/default/TopLevel.js @@ -288,7 +288,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/29f47.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/29f47.json/default/TopLevel.js index c0ba159..b89e1c0 100644 --- a/base/flow/test/inputs/json/misc/29f47.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/29f47.json/default/TopLevel.js @@ -274,7 +274,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/2d4e2.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/2d4e2.json/default/TopLevel.js index a78c314..245ea8e 100644 --- a/base/flow/test/inputs/json/misc/2d4e2.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/2d4e2.json/default/TopLevel.js @@ -242,7 +242,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/2df80.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/2df80.json/default/TopLevel.js index 3a22850..1f6626f 100644 --- a/base/flow/test/inputs/json/misc/2df80.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/2df80.json/default/TopLevel.js @@ -208,7 +208,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/31189.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/31189.json/default/TopLevel.js index 3eac00b..d66b9f3 100644 --- a/base/flow/test/inputs/json/misc/31189.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/31189.json/default/TopLevel.js @@ -163,7 +163,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/32431.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/32431.json/default/TopLevel.js index 8c2879f..de29f34 100644 --- a/base/flow/test/inputs/json/misc/32431.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/32431.json/default/TopLevel.js @@ -206,7 +206,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/32d5c.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/32d5c.json/default/TopLevel.js index 7eccb8d..5dc52af 100644 --- a/base/flow/test/inputs/json/misc/32d5c.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/32d5c.json/default/TopLevel.js @@ -144,7 +144,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/337ed.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/337ed.json/default/TopLevel.js index 79aca28..19cc649 100644 --- a/base/flow/test/inputs/json/misc/337ed.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/337ed.json/default/TopLevel.js @@ -203,7 +203,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/33d2e.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/33d2e.json/default/TopLevel.js index 453bfdc..6f9cdad 100644 --- a/base/flow/test/inputs/json/misc/33d2e.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/33d2e.json/default/TopLevel.js @@ -188,7 +188,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/34702.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/34702.json/default/TopLevel.js index e2b147f..2c87ab2 100644 --- a/base/flow/test/inputs/json/misc/34702.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/34702.json/default/TopLevel.js @@ -223,7 +223,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/3536b.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/3536b.json/default/TopLevel.js index d6e56cf..3ac9dd6 100644 --- a/base/flow/test/inputs/json/misc/3536b.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/3536b.json/default/TopLevel.js @@ -170,7 +170,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/3659d.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/3659d.json/default/TopLevel.js index c2c007d..cbe621d 100644 --- a/base/flow/test/inputs/json/misc/3659d.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/3659d.json/default/TopLevel.js @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/36d5d.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/36d5d.json/default/TopLevel.js index a07dba1..3d06c27 100644 --- a/base/flow/test/inputs/json/misc/36d5d.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/36d5d.json/default/TopLevel.js @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/3a6b3.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/3a6b3.json/default/TopLevel.js index a07dba1..3d06c27 100644 --- a/base/flow/test/inputs/json/misc/3a6b3.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/3a6b3.json/default/TopLevel.js @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/3e9a3.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/3e9a3.json/default/TopLevel.js index 8311c33..7fdf613 100644 --- a/base/flow/test/inputs/json/misc/3e9a3.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/3e9a3.json/default/TopLevel.js @@ -160,7 +160,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/3f1ce.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/3f1ce.json/default/TopLevel.js index 59024c0..ffe7713 100644 --- a/base/flow/test/inputs/json/misc/3f1ce.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/3f1ce.json/default/TopLevel.js @@ -236,7 +236,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/421d4.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/421d4.json/default/TopLevel.js index 2974976..797e37c 100644 --- a/base/flow/test/inputs/json/misc/421d4.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/421d4.json/default/TopLevel.js @@ -249,7 +249,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/437e7.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/437e7.json/default/TopLevel.js index 7712980..fe52e33 100644 --- a/base/flow/test/inputs/json/misc/437e7.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/437e7.json/default/TopLevel.js @@ -244,7 +244,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/43970.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/43970.json/default/TopLevel.js index 7a4cfc8..91eaf78 100644 --- a/base/flow/test/inputs/json/misc/43970.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/43970.json/default/TopLevel.js @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/43eaf.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/43eaf.json/default/TopLevel.js index 2ae4813..5fa36d1 100644 --- a/base/flow/test/inputs/json/misc/43eaf.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/43eaf.json/default/TopLevel.js @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/458db.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/458db.json/default/TopLevel.js index 113a18d..e5a3e27 100644 --- a/base/flow/test/inputs/json/misc/458db.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/458db.json/default/TopLevel.js @@ -178,7 +178,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (typeof typ === "object") { return typ.hasOwnProperty("uuid") ? typeof val === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(val) ? val : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/4961a.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/4961a.json/default/TopLevel.js index c2c007d..cbe621d 100644 --- a/base/flow/test/inputs/json/misc/4961a.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/4961a.json/default/TopLevel.js @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/4a0d7.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/4a0d7.json/default/TopLevel.js index c2c007d..cbe621d 100644 --- a/base/flow/test/inputs/json/misc/4a0d7.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/4a0d7.json/default/TopLevel.js @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/4a455.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/4a455.json/default/TopLevel.js index 52def58..4a31419 100644 --- a/base/flow/test/inputs/json/misc/4a455.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/4a455.json/default/TopLevel.js @@ -178,7 +178,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/4c547.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/4c547.json/default/TopLevel.js index 704d101..e5480dc 100644 --- a/base/flow/test/inputs/json/misc/4c547.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/4c547.json/default/TopLevel.js @@ -233,7 +233,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/4d6fb.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/4d6fb.json/default/TopLevel.js index 43fa073..c52f7ca 100644 --- a/base/flow/test/inputs/json/misc/4d6fb.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/4d6fb.json/default/TopLevel.js @@ -283,7 +283,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/4e336.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/4e336.json/default/TopLevel.js index c2c007d..cbe621d 100644 --- a/base/flow/test/inputs/json/misc/4e336.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/4e336.json/default/TopLevel.js @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/54147.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/54147.json/default/TopLevel.js index 9d2cb7a..20b1b87 100644 --- a/base/flow/test/inputs/json/misc/54147.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/54147.json/default/TopLevel.js @@ -151,7 +151,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/54d32.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/54d32.json/default/TopLevel.js index efa659f..c0b24bd 100644 --- a/base/flow/test/inputs/json/misc/54d32.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/54d32.json/default/TopLevel.js @@ -157,7 +157,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/570ec.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/570ec.json/default/TopLevel.js index 9ef958f..96b0202 100644 --- a/base/flow/test/inputs/json/misc/570ec.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/570ec.json/default/TopLevel.js @@ -170,7 +170,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/5dd0d.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/5dd0d.json/default/TopLevel.js index a07dba1..3d06c27 100644 --- a/base/flow/test/inputs/json/misc/5dd0d.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/5dd0d.json/default/TopLevel.js @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/5eae5.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/5eae5.json/default/TopLevel.js index 060d57c..3269b79 100644 --- a/base/flow/test/inputs/json/misc/5eae5.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/5eae5.json/default/TopLevel.js @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/5eb20.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/5eb20.json/default/TopLevel.js index a07dba1..3d06c27 100644 --- a/base/flow/test/inputs/json/misc/5eb20.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/5eb20.json/default/TopLevel.js @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/5f3a1.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/5f3a1.json/default/TopLevel.js index 2ae4813..5fa36d1 100644 --- a/base/flow/test/inputs/json/misc/5f3a1.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/5f3a1.json/default/TopLevel.js @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/5f7fe.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/5f7fe.json/default/TopLevel.js index 6571d23..80d7a26 100644 --- a/base/flow/test/inputs/json/misc/5f7fe.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/5f7fe.json/default/TopLevel.js @@ -323,7 +323,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/617e8.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/617e8.json/default/TopLevel.js index 2522d6c..5809480 100644 --- a/base/flow/test/inputs/json/misc/617e8.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/617e8.json/default/TopLevel.js @@ -322,7 +322,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/61b66.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/61b66.json/default/TopLevel.js index a07dba1..3d06c27 100644 --- a/base/flow/test/inputs/json/misc/61b66.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/61b66.json/default/TopLevel.js @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/6260a.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/6260a.json/default/TopLevel.js index 2ae4813..5fa36d1 100644 --- a/base/flow/test/inputs/json/misc/6260a.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/6260a.json/default/TopLevel.js @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/65dec.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/65dec.json/default/TopLevel.js index 3e305ab..48647e3 100644 --- a/base/flow/test/inputs/json/misc/65dec.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/65dec.json/default/TopLevel.js @@ -222,7 +222,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/66121.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/66121.json/default/TopLevel.js index 105594b..7c074a0 100644 --- a/base/flow/test/inputs/json/misc/66121.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/66121.json/default/TopLevel.js @@ -179,7 +179,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/6617c.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/6617c.json/default/TopLevel.js index 4375d14..ca8ef0f 100644 --- a/base/flow/test/inputs/json/misc/6617c.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/6617c.json/default/TopLevel.js @@ -142,7 +142,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/67c03.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/67c03.json/default/TopLevel.js index 656f18f..8e41d6e 100644 --- a/base/flow/test/inputs/json/misc/67c03.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/67c03.json/default/TopLevel.js @@ -142,7 +142,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/68c30.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/68c30.json/default/TopLevel.js index 942680a..1e83aa2 100644 --- a/base/flow/test/inputs/json/misc/68c30.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/68c30.json/default/TopLevel.js @@ -166,7 +166,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/6c155.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/6c155.json/default/TopLevel.js index 2f599b1..2d265b0 100644 --- a/base/flow/test/inputs/json/misc/6c155.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/6c155.json/default/TopLevel.js @@ -189,7 +189,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (typeof typ === "object") { return typ.hasOwnProperty("uuid") ? typeof val === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(val) ? val : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/6de06.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/6de06.json/default/TopLevel.js index e587b05..36eb35c 100644 --- a/base/flow/test/inputs/json/misc/6de06.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/6de06.json/default/TopLevel.js @@ -283,7 +283,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/6dec6.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/6dec6.json/default/TopLevel.js index f804b47..957598e 100644 --- a/base/flow/test/inputs/json/misc/6dec6.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/6dec6.json/default/TopLevel.js @@ -238,7 +238,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/6eb00.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/6eb00.json/default/TopLevel.js index 89db339..7e6c5f1 100644 --- a/base/flow/test/inputs/json/misc/6eb00.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/6eb00.json/default/TopLevel.js @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/70c77.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/70c77.json/default/TopLevel.js index 2ae4813..5fa36d1 100644 --- a/base/flow/test/inputs/json/misc/70c77.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/70c77.json/default/TopLevel.js @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/734ad.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/734ad.json/default/TopLevel.js index d21ec47..16ed733 100644 --- a/base/flow/test/inputs/json/misc/734ad.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/734ad.json/default/TopLevel.js @@ -209,7 +209,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/75912.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/75912.json/default/TopLevel.js index 2ae4813..5fa36d1 100644 --- a/base/flow/test/inputs/json/misc/75912.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/75912.json/default/TopLevel.js @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/7681c.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/7681c.json/default/TopLevel.js index 4146020..3fee931 100644 --- a/base/flow/test/inputs/json/misc/7681c.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/7681c.json/default/TopLevel.js @@ -251,7 +251,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/76ae1.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/76ae1.json/default/TopLevel.js index 5ec1c7c..14d01a4 100644 --- a/base/flow/test/inputs/json/misc/76ae1.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/76ae1.json/default/TopLevel.js @@ -319,7 +319,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/77392.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/77392.json/default/TopLevel.js index 53a2dde..a7509f3 100644 --- a/base/flow/test/inputs/json/misc/77392.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/77392.json/default/TopLevel.js @@ -162,7 +162,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/7d397.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/7d397.json/default/TopLevel.js index 8e42f75..f5f4c9c 100644 --- a/base/flow/test/inputs/json/misc/7d397.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/7d397.json/default/TopLevel.js @@ -210,7 +210,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/7d722.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/7d722.json/default/TopLevel.js index a07dba1..3d06c27 100644 --- a/base/flow/test/inputs/json/misc/7d722.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/7d722.json/default/TopLevel.js @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/7df41.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/7df41.json/default/TopLevel.js index 4393320..0b3ca2e 100644 --- a/base/flow/test/inputs/json/misc/7df41.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/7df41.json/default/TopLevel.js @@ -145,7 +145,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/7dfa6.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/7dfa6.json/default/TopLevel.js index c2c007d..cbe621d 100644 --- a/base/flow/test/inputs/json/misc/7dfa6.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/7dfa6.json/default/TopLevel.js @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/7eb30.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/7eb30.json/default/TopLevel.js index 1106eed..1657849 100644 --- a/base/flow/test/inputs/json/misc/7eb30.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/7eb30.json/default/TopLevel.js @@ -179,7 +179,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/7f568.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/7f568.json/default/TopLevel.js index 9dec2ca..bdf0c1b 100644 --- a/base/flow/test/inputs/json/misc/7f568.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/7f568.json/default/TopLevel.js @@ -166,7 +166,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/7fbfb.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/7fbfb.json/default/TopLevel.js index 973db80..982e944 100644 --- a/base/flow/test/inputs/json/misc/7fbfb.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/7fbfb.json/default/TopLevel.js @@ -163,7 +163,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/80aff.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/80aff.json/default/TopLevel.js index 42e855b..936aad8 100644 --- a/base/flow/test/inputs/json/misc/80aff.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/80aff.json/default/TopLevel.js @@ -154,7 +154,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/82509.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/82509.json/default/TopLevel.js index de9c80d..4415a6d 100644 --- a/base/flow/test/inputs/json/misc/82509.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/82509.json/default/TopLevel.js @@ -135,7 +135,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/8592b.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/8592b.json/default/TopLevel.js index 3e80895..117adcc 100644 --- a/base/flow/test/inputs/json/misc/8592b.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/8592b.json/default/TopLevel.js @@ -258,7 +258,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/88130.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/88130.json/default/TopLevel.js index 704d101..e5480dc 100644 --- a/base/flow/test/inputs/json/misc/88130.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/88130.json/default/TopLevel.js @@ -233,7 +233,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/8a62c.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/8a62c.json/default/TopLevel.js index c2c007d..cbe621d 100644 --- a/base/flow/test/inputs/json/misc/8a62c.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/8a62c.json/default/TopLevel.js @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/908db.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/908db.json/default/TopLevel.js index eddef7b..b1365ea 100644 --- a/base/flow/test/inputs/json/misc/908db.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/908db.json/default/TopLevel.js @@ -144,7 +144,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/9617f.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/9617f.json/default/TopLevel.js index 2ae4813..5fa36d1 100644 --- a/base/flow/test/inputs/json/misc/9617f.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/9617f.json/default/TopLevel.js @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/96f7c.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/96f7c.json/default/TopLevel.js index 700e5c2..3e323b2 100644 --- a/base/flow/test/inputs/json/misc/96f7c.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/96f7c.json/default/TopLevel.js @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/9847b.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/9847b.json/default/TopLevel.js index 352402c..c6fa41c 100644 --- a/base/flow/test/inputs/json/misc/9847b.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/9847b.json/default/TopLevel.js @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/9929c.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/9929c.json/default/TopLevel.js index 704d101..e5480dc 100644 --- a/base/flow/test/inputs/json/misc/9929c.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/9929c.json/default/TopLevel.js @@ -233,7 +233,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/996bd.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/996bd.json/default/TopLevel.js index 25323db..0cab598 100644 --- a/base/flow/test/inputs/json/misc/996bd.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/996bd.json/default/TopLevel.js @@ -179,7 +179,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/9a503.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/9a503.json/default/TopLevel.js index f262bd5..4bb86ec 100644 --- a/base/flow/test/inputs/json/misc/9a503.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/9a503.json/default/TopLevel.js @@ -165,7 +165,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/9ac3b.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/9ac3b.json/default/TopLevel.js index 78f370b..c5aebc8 100644 --- a/base/flow/test/inputs/json/misc/9ac3b.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/9ac3b.json/default/TopLevel.js @@ -166,7 +166,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/9eed5.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/9eed5.json/default/TopLevel.js index b74716c..cc710c9 100644 --- a/base/flow/test/inputs/json/misc/9eed5.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/9eed5.json/default/TopLevel.js @@ -164,7 +164,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/a0496.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/a0496.json/default/TopLevel.js index 989f309..4c44164 100644 --- a/base/flow/test/inputs/json/misc/a0496.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/a0496.json/default/TopLevel.js @@ -156,7 +156,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/a1eca.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/a1eca.json/default/TopLevel.js index 704d101..e5480dc 100644 --- a/base/flow/test/inputs/json/misc/a1eca.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/a1eca.json/default/TopLevel.js @@ -233,7 +233,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/a3d8c.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/a3d8c.json/default/TopLevel.js index 9717075..1863828 100644 --- a/base/flow/test/inputs/json/misc/a3d8c.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/a3d8c.json/default/TopLevel.js @@ -251,7 +251,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/a45b0.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/a45b0.json/default/TopLevel.js index 666804a..f84af0d 100644 --- a/base/flow/test/inputs/json/misc/a45b0.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/a45b0.json/default/TopLevel.js @@ -145,7 +145,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/a71df.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/a71df.json/default/TopLevel.js index a07dba1..3d06c27 100644 --- a/base/flow/test/inputs/json/misc/a71df.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/a71df.json/default/TopLevel.js @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/a9691.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/a9691.json/default/TopLevel.js index 2ae4813..5fa36d1 100644 --- a/base/flow/test/inputs/json/misc/a9691.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/a9691.json/default/TopLevel.js @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/ab0d1.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/ab0d1.json/default/TopLevel.js index 666804a..f84af0d 100644 --- a/base/flow/test/inputs/json/misc/ab0d1.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/ab0d1.json/default/TopLevel.js @@ -145,7 +145,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/abb4b.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/abb4b.json/default/TopLevel.js index c2c007d..cbe621d 100644 --- a/base/flow/test/inputs/json/misc/abb4b.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/abb4b.json/default/TopLevel.js @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/ac944.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/ac944.json/default/TopLevel.js index 2ae4813..5fa36d1 100644 --- a/base/flow/test/inputs/json/misc/ac944.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/ac944.json/default/TopLevel.js @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/ad8be.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/ad8be.json/default/TopLevel.js index 1fc02c1..22a5277 100644 --- a/base/flow/test/inputs/json/misc/ad8be.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/ad8be.json/default/TopLevel.js @@ -202,7 +202,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/ae7f0.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/ae7f0.json/default/TopLevel.js index 11afdfe..7f35c44 100644 --- a/base/flow/test/inputs/json/misc/ae7f0.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/ae7f0.json/default/TopLevel.js @@ -232,7 +232,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/ae9ca.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/ae9ca.json/default/TopLevel.js index 8f0a2eb..03e9fba 100644 --- a/base/flow/test/inputs/json/misc/ae9ca.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/ae9ca.json/default/TopLevel.js @@ -181,7 +181,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/af2d1.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/af2d1.json/default/TopLevel.js index 921f0c2..febdb35 100644 --- a/base/flow/test/inputs/json/misc/af2d1.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/af2d1.json/default/TopLevel.js @@ -243,7 +243,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/b4865.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/b4865.json/default/TopLevel.js index b965e11..715a5ec 100644 --- a/base/flow/test/inputs/json/misc/b4865.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/b4865.json/default/TopLevel.js @@ -163,7 +163,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/b6f2c.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/b6f2c.json/default/TopLevel.js index c2c007d..cbe621d 100644 --- a/base/flow/test/inputs/json/misc/b6f2c.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/b6f2c.json/default/TopLevel.js @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/b6fe5.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/b6fe5.json/default/TopLevel.js index 59ad879..32a8f00 100644 --- a/base/flow/test/inputs/json/misc/b6fe5.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/b6fe5.json/default/TopLevel.js @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/b9f64.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/b9f64.json/default/TopLevel.js index 767bc9b..37dcbf0 100644 --- a/base/flow/test/inputs/json/misc/b9f64.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/b9f64.json/default/TopLevel.js @@ -135,7 +135,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/bb1ec.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/bb1ec.json/default/TopLevel.js index c2c007d..cbe621d 100644 --- a/base/flow/test/inputs/json/misc/bb1ec.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/bb1ec.json/default/TopLevel.js @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/be234.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/be234.json/default/TopLevel.js index efc7121..618f294 100644 --- a/base/flow/test/inputs/json/misc/be234.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/be234.json/default/TopLevel.js @@ -297,7 +297,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/c0356.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/c0356.json/default/TopLevel.js index 82444c9..0bae148 100644 --- a/base/flow/test/inputs/json/misc/c0356.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/c0356.json/default/TopLevel.js @@ -147,7 +147,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/c0a3a.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/c0a3a.json/default/TopLevel.js index a07dba1..3d06c27 100644 --- a/base/flow/test/inputs/json/misc/c0a3a.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/c0a3a.json/default/TopLevel.js @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/c3303.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/c3303.json/default/TopLevel.js index 1ca909c..6e2391c 100644 --- a/base/flow/test/inputs/json/misc/c3303.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/c3303.json/default/TopLevel.js @@ -248,7 +248,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/c6cfd.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/c6cfd.json/default/TopLevel.js index 5f22df7..0cd5f59 100644 --- a/base/flow/test/inputs/json/misc/c6cfd.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/c6cfd.json/default/TopLevel.js @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/c8c7e.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/c8c7e.json/default/TopLevel.js index 7342b40..175b9e8 100644 --- a/base/flow/test/inputs/json/misc/c8c7e.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/c8c7e.json/default/TopLevel.js @@ -163,7 +163,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/cb0cc.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/cb0cc.json/default/TopLevel.js index 0681c13..a54070f 100644 --- a/base/flow/test/inputs/json/misc/cb0cc.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/cb0cc.json/default/TopLevel.js @@ -158,7 +158,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/cb81e.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/cb81e.json/default/TopLevel.js index 9663ec2..40e5d6f 100644 --- a/base/flow/test/inputs/json/misc/cb81e.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/cb81e.json/default/TopLevel.js @@ -143,7 +143,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/ccd18.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/ccd18.json/default/TopLevel.js index a07dba1..3d06c27 100644 --- a/base/flow/test/inputs/json/misc/ccd18.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/ccd18.json/default/TopLevel.js @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/cd238.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/cd238.json/default/TopLevel.js index a07dba1..3d06c27 100644 --- a/base/flow/test/inputs/json/misc/cd238.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/cd238.json/default/TopLevel.js @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/cd463.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/cd463.json/default/TopLevel.js index 2ae4813..5fa36d1 100644 --- a/base/flow/test/inputs/json/misc/cd463.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/cd463.json/default/TopLevel.js @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/cda6c.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/cda6c.json/default/TopLevel.js index 0af0cd4..2606af6 100644 --- a/base/flow/test/inputs/json/misc/cda6c.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/cda6c.json/default/TopLevel.js @@ -163,7 +163,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/cf0d8.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/cf0d8.json/default/TopLevel.js index 704d101..e5480dc 100644 --- a/base/flow/test/inputs/json/misc/cf0d8.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/cf0d8.json/default/TopLevel.js @@ -233,7 +233,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/cfbce.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/cfbce.json/default/TopLevel.js index 2ae4813..5fa36d1 100644 --- a/base/flow/test/inputs/json/misc/cfbce.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/cfbce.json/default/TopLevel.js @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/d0908.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/d0908.json/default/TopLevel.js index c2c007d..cbe621d 100644 --- a/base/flow/test/inputs/json/misc/d0908.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/d0908.json/default/TopLevel.js @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/d23d5.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/d23d5.json/default/TopLevel.js index 29f090e..3307221 100644 --- a/base/flow/test/inputs/json/misc/d23d5.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/d23d5.json/default/TopLevel.js @@ -153,7 +153,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/dbfb3.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/dbfb3.json/default/TopLevel.js index 48e64c8..3ca6bba 100644 --- a/base/flow/test/inputs/json/misc/dbfb3.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/dbfb3.json/default/TopLevel.js @@ -237,7 +237,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/dc44f.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/dc44f.json/default/TopLevel.js index b7ac151..6c56d4d 100644 --- a/base/flow/test/inputs/json/misc/dc44f.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/dc44f.json/default/TopLevel.js @@ -261,7 +261,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/dd1ce.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/dd1ce.json/default/TopLevel.js index b7ac151..6c56d4d 100644 --- a/base/flow/test/inputs/json/misc/dd1ce.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/dd1ce.json/default/TopLevel.js @@ -261,7 +261,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/dec3a.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/dec3a.json/default/TopLevel.js index c75a6b2..c872aa9 100644 --- a/base/flow/test/inputs/json/misc/dec3a.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/dec3a.json/default/TopLevel.js @@ -197,7 +197,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (typeof typ === "object") { return typ.hasOwnProperty("uuid") ? typeof val === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(val) ? val : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/df957.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/df957.json/default/TopLevel.js index 704d101..e5480dc 100644 --- a/base/flow/test/inputs/json/misc/df957.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/df957.json/default/TopLevel.js @@ -233,7 +233,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/e0ac7.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/e0ac7.json/default/TopLevel.js index 97ba079..b10a4fd 100644 --- a/base/flow/test/inputs/json/misc/e0ac7.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/e0ac7.json/default/TopLevel.js @@ -245,7 +245,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/e2915.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/e2915.json/default/TopLevel.js index 49a78f9..3fb53d2 100644 --- a/base/flow/test/inputs/json/misc/e2915.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/e2915.json/default/TopLevel.js @@ -236,7 +236,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/e2a58.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/e2a58.json/default/TopLevel.js index f655445..ff7cead 100644 --- a/base/flow/test/inputs/json/misc/e2a58.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/e2a58.json/default/TopLevel.js @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/e324e.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/e324e.json/default/TopLevel.js index bf50666..a4e43e9 100644 --- a/base/flow/test/inputs/json/misc/e324e.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/e324e.json/default/TopLevel.js @@ -207,7 +207,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/e53b5.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/e53b5.json/default/TopLevel.js index 437c982..f87432b 100644 --- a/base/flow/test/inputs/json/misc/e53b5.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/e53b5.json/default/TopLevel.js @@ -163,7 +163,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/e64a0.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/e64a0.json/default/TopLevel.js index 2611898..6e0d3c1 100644 --- a/base/flow/test/inputs/json/misc/e64a0.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/e64a0.json/default/TopLevel.js @@ -148,7 +148,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/e8a0b.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/e8a0b.json/default/TopLevel.js index 666804a..f84af0d 100644 --- a/base/flow/test/inputs/json/misc/e8a0b.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/e8a0b.json/default/TopLevel.js @@ -145,7 +145,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/e8b04.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/e8b04.json/default/TopLevel.js index 2c1dfce..fe32852 100644 --- a/base/flow/test/inputs/json/misc/e8b04.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/e8b04.json/default/TopLevel.js @@ -405,7 +405,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/ed095.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/ed095.json/default/TopLevel.js index 0139657..a7c4403 100644 --- a/base/flow/test/inputs/json/misc/ed095.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/ed095.json/default/TopLevel.js @@ -133,7 +133,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/f22f5.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/f22f5.json/default/TopLevel.js index 7eb9210..c64073a 100644 --- a/base/flow/test/inputs/json/misc/f22f5.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/f22f5.json/default/TopLevel.js @@ -229,7 +229,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/f3139.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/f3139.json/default/TopLevel.js index 352402c..c6fa41c 100644 --- a/base/flow/test/inputs/json/misc/f3139.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/f3139.json/default/TopLevel.js @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/f3edf.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/f3edf.json/default/TopLevel.js index 666804a..f84af0d 100644 --- a/base/flow/test/inputs/json/misc/f3edf.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/f3edf.json/default/TopLevel.js @@ -145,7 +145,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/f466a.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/f466a.json/default/TopLevel.js index 666804a..f84af0d 100644 --- a/base/flow/test/inputs/json/misc/f466a.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/f466a.json/default/TopLevel.js @@ -145,7 +145,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/f6a65.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/f6a65.json/default/TopLevel.js index 8f1c326..dbdbf21 100644 --- a/base/flow/test/inputs/json/misc/f6a65.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/f6a65.json/default/TopLevel.js @@ -252,7 +252,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/f74d5.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/f74d5.json/default/TopLevel.js index 8e9db3a..0a6f61c 100644 --- a/base/flow/test/inputs/json/misc/f74d5.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/f74d5.json/default/TopLevel.js @@ -251,7 +251,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/f82d9.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/f82d9.json/default/TopLevel.js index 84be934..d0556f7 100644 --- a/base/flow/test/inputs/json/misc/f82d9.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/f82d9.json/default/TopLevel.js @@ -220,7 +220,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/f974d.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/f974d.json/default/TopLevel.js index 4c8ed85..ce5a641 100644 --- a/base/flow/test/inputs/json/misc/f974d.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/f974d.json/default/TopLevel.js @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/faff5.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/faff5.json/default/TopLevel.js index e84344e..f99d30d 100644 --- a/base/flow/test/inputs/json/misc/faff5.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/faff5.json/default/TopLevel.js @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/fcca3.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/fcca3.json/default/TopLevel.js index a714023..6121ebf 100644 --- a/base/flow/test/inputs/json/misc/fcca3.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/fcca3.json/default/TopLevel.js @@ -348,7 +348,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/misc/fd329.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/fd329.json/default/TopLevel.js index ddea840..cdfaa32 100644 --- a/base/flow/test/inputs/json/misc/fd329.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/fd329.json/default/TopLevel.js @@ -148,7 +148,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/blns-object.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/blns-object.json/default/TopLevel.js index 5039626..72b32e5 100644 --- a/base/flow/test/inputs/json/priority/blns-object.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/blns-object.json/default/TopLevel.js @@ -730,7 +730,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/bug2037.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/bug2037.json/default/TopLevel.js index 73ebd8e..56fb38a 100644 --- a/base/flow/test/inputs/json/priority/bug2037.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/bug2037.json/default/TopLevel.js @@ -146,7 +146,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/bug2521.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/bug2521.json/default/TopLevel.js index 8c1629d..f30e5b4 100644 --- a/base/flow/test/inputs/json/priority/bug2521.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/bug2521.json/default/TopLevel.js @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/bug2590.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/bug2590.json/default/TopLevel.js index 8625ee8..0ff795d 100644 --- a/base/flow/test/inputs/json/priority/bug2590.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/bug2590.json/default/TopLevel.js @@ -141,7 +141,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/bug2663.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/bug2663.json/default/TopLevel.js index 8c7e069..a40eac7 100644 --- a/base/flow/test/inputs/json/priority/bug2663.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/bug2663.json/default/TopLevel.js @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/bug2793.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/bug2793.json/default/TopLevel.js index 82cc898..9e8ca62 100644 --- a/base/flow/test/inputs/json/priority/bug2793.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/bug2793.json/default/TopLevel.js @@ -144,7 +144,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/bug427.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/bug427.json/default/TopLevel.js index 9deb49f..4e83eaa 100644 --- a/base/flow/test/inputs/json/priority/bug427.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/bug427.json/default/TopLevel.js @@ -746,7 +746,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/bug790.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/bug790.json/default/TopLevel.js index 67e4f76..86226fd 100644 --- a/base/flow/test/inputs/json/priority/bug790.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/bug790.json/default/TopLevel.js @@ -142,7 +142,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/bug855-short.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/bug855-short.json/default/TopLevel.js index 2713d71..4d40fe1 100644 --- a/base/flow/test/inputs/json/priority/bug855-short.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/bug855-short.json/default/TopLevel.js @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/bug863.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/bug863.json/default/TopLevel.js index 79dff4e..873b3ae 100644 --- a/base/flow/test/inputs/json/priority/bug863.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/bug863.json/default/TopLevel.js @@ -221,7 +221,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/coin-pairs.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/coin-pairs.json/default/TopLevel.js index ae3caec..7eaadc1 100644 --- a/base/flow/test/inputs/json/priority/coin-pairs.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/coin-pairs.json/default/TopLevel.js @@ -147,7 +147,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/combinations1.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/combinations1.json/default/TopLevel.js index 471d5ef..8f831c4 100644 --- a/base/flow/test/inputs/json/priority/combinations1.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/combinations1.json/default/TopLevel.js @@ -527,7 +527,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/combinations1.json/nice-property-names-true--f4d7920ee2ce/TopLevel.js b/head/flow/test/inputs/json/priority/combinations1.json/nice-property-names-true--f4d7920ee2ce/TopLevel.js index c0ed060..5a250ee 100644 --- a/base/flow/test/inputs/json/priority/combinations1.json/nice-property-names-true--f4d7920ee2ce/TopLevel.js +++ b/head/flow/test/inputs/json/priority/combinations1.json/nice-property-names-true--f4d7920ee2ce/TopLevel.js @@ -527,7 +527,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/combinations1.json/prefer-unions-false--a5053c0a486d/TopLevel.js b/head/flow/test/inputs/json/priority/combinations1.json/prefer-unions-false--a5053c0a486d/TopLevel.js index 471d5ef..8f831c4 100644 --- a/base/flow/test/inputs/json/priority/combinations1.json/prefer-unions-false--a5053c0a486d/TopLevel.js +++ b/head/flow/test/inputs/json/priority/combinations1.json/prefer-unions-false--a5053c0a486d/TopLevel.js @@ -527,7 +527,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/combinations1.json/prefer-unknown-false--f1ab9e45d823/TopLevel.js b/head/flow/test/inputs/json/priority/combinations1.json/prefer-unknown-false--f1ab9e45d823/TopLevel.js index 471d5ef..8f831c4 100644 --- a/base/flow/test/inputs/json/priority/combinations1.json/prefer-unknown-false--f1ab9e45d823/TopLevel.js +++ b/head/flow/test/inputs/json/priority/combinations1.json/prefer-unknown-false--f1ab9e45d823/TopLevel.js @@ -527,7 +527,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/combinations1.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js b/head/flow/test/inputs/json/priority/combinations1.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js index 367dbf7..d304189 100644 --- a/base/flow/test/inputs/json/priority/combinations1.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js +++ b/head/flow/test/inputs/json/priority/combinations1.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js @@ -527,7 +527,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/combinations2.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/combinations2.json/default/TopLevel.js index c65cd0a..510e574 100644 --- a/base/flow/test/inputs/json/priority/combinations2.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/combinations2.json/default/TopLevel.js @@ -479,7 +479,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/combinations2.json/nice-property-names-true--f4d7920ee2ce/TopLevel.js b/head/flow/test/inputs/json/priority/combinations2.json/nice-property-names-true--f4d7920ee2ce/TopLevel.js index 5f4b38b..40d15ab 100644 --- a/base/flow/test/inputs/json/priority/combinations2.json/nice-property-names-true--f4d7920ee2ce/TopLevel.js +++ b/head/flow/test/inputs/json/priority/combinations2.json/nice-property-names-true--f4d7920ee2ce/TopLevel.js @@ -479,7 +479,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/combinations2.json/prefer-unions-false--a5053c0a486d/TopLevel.js b/head/flow/test/inputs/json/priority/combinations2.json/prefer-unions-false--a5053c0a486d/TopLevel.js index c65cd0a..510e574 100644 --- a/base/flow/test/inputs/json/priority/combinations2.json/prefer-unions-false--a5053c0a486d/TopLevel.js +++ b/head/flow/test/inputs/json/priority/combinations2.json/prefer-unions-false--a5053c0a486d/TopLevel.js @@ -479,7 +479,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/combinations2.json/prefer-unknown-false--f1ab9e45d823/TopLevel.js b/head/flow/test/inputs/json/priority/combinations2.json/prefer-unknown-false--f1ab9e45d823/TopLevel.js index c65cd0a..510e574 100644 --- a/base/flow/test/inputs/json/priority/combinations2.json/prefer-unknown-false--f1ab9e45d823/TopLevel.js +++ b/head/flow/test/inputs/json/priority/combinations2.json/prefer-unknown-false--f1ab9e45d823/TopLevel.js @@ -479,7 +479,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/combinations2.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js b/head/flow/test/inputs/json/priority/combinations2.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js index 5299a0c..9b9ad73 100644 --- a/base/flow/test/inputs/json/priority/combinations2.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js +++ b/head/flow/test/inputs/json/priority/combinations2.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js @@ -479,7 +479,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/combinations3.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/combinations3.json/default/TopLevel.js index 2917fea..f16fccf 100644 --- a/base/flow/test/inputs/json/priority/combinations3.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/combinations3.json/default/TopLevel.js @@ -583,7 +583,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/combinations3.json/nice-property-names-true--f4d7920ee2ce/TopLevel.js b/head/flow/test/inputs/json/priority/combinations3.json/nice-property-names-true--f4d7920ee2ce/TopLevel.js index 87730a3..6681434 100644 --- a/base/flow/test/inputs/json/priority/combinations3.json/nice-property-names-true--f4d7920ee2ce/TopLevel.js +++ b/head/flow/test/inputs/json/priority/combinations3.json/nice-property-names-true--f4d7920ee2ce/TopLevel.js @@ -583,7 +583,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/combinations3.json/prefer-unions-false--a5053c0a486d/TopLevel.js b/head/flow/test/inputs/json/priority/combinations3.json/prefer-unions-false--a5053c0a486d/TopLevel.js index 2917fea..f16fccf 100644 --- a/base/flow/test/inputs/json/priority/combinations3.json/prefer-unions-false--a5053c0a486d/TopLevel.js +++ b/head/flow/test/inputs/json/priority/combinations3.json/prefer-unions-false--a5053c0a486d/TopLevel.js @@ -583,7 +583,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/combinations3.json/prefer-unknown-false--f1ab9e45d823/TopLevel.js b/head/flow/test/inputs/json/priority/combinations3.json/prefer-unknown-false--f1ab9e45d823/TopLevel.js index 2917fea..f16fccf 100644 --- a/base/flow/test/inputs/json/priority/combinations3.json/prefer-unknown-false--f1ab9e45d823/TopLevel.js +++ b/head/flow/test/inputs/json/priority/combinations3.json/prefer-unknown-false--f1ab9e45d823/TopLevel.js @@ -583,7 +583,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/combinations3.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js b/head/flow/test/inputs/json/priority/combinations3.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js index 492f21d..dac2f81 100644 --- a/base/flow/test/inputs/json/priority/combinations3.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js +++ b/head/flow/test/inputs/json/priority/combinations3.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js @@ -583,7 +583,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/combinations4.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/combinations4.json/default/TopLevel.js index bd03cb9..1b76a6c 100644 --- a/base/flow/test/inputs/json/priority/combinations4.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/combinations4.json/default/TopLevel.js @@ -653,7 +653,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/combinations4.json/nice-property-names-true--f4d7920ee2ce/TopLevel.js b/head/flow/test/inputs/json/priority/combinations4.json/nice-property-names-true--f4d7920ee2ce/TopLevel.js index c025003..e235b35 100644 --- a/base/flow/test/inputs/json/priority/combinations4.json/nice-property-names-true--f4d7920ee2ce/TopLevel.js +++ b/head/flow/test/inputs/json/priority/combinations4.json/nice-property-names-true--f4d7920ee2ce/TopLevel.js @@ -653,7 +653,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/combinations4.json/prefer-unions-false--a5053c0a486d/TopLevel.js b/head/flow/test/inputs/json/priority/combinations4.json/prefer-unions-false--a5053c0a486d/TopLevel.js index bd03cb9..1b76a6c 100644 --- a/base/flow/test/inputs/json/priority/combinations4.json/prefer-unions-false--a5053c0a486d/TopLevel.js +++ b/head/flow/test/inputs/json/priority/combinations4.json/prefer-unions-false--a5053c0a486d/TopLevel.js @@ -653,7 +653,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/combinations4.json/prefer-unknown-false--f1ab9e45d823/TopLevel.js b/head/flow/test/inputs/json/priority/combinations4.json/prefer-unknown-false--f1ab9e45d823/TopLevel.js index bd03cb9..1b76a6c 100644 --- a/base/flow/test/inputs/json/priority/combinations4.json/prefer-unknown-false--f1ab9e45d823/TopLevel.js +++ b/head/flow/test/inputs/json/priority/combinations4.json/prefer-unknown-false--f1ab9e45d823/TopLevel.js @@ -653,7 +653,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/combinations4.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js b/head/flow/test/inputs/json/priority/combinations4.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js index 78bf87d..a467e53 100644 --- a/base/flow/test/inputs/json/priority/combinations4.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js +++ b/head/flow/test/inputs/json/priority/combinations4.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js @@ -653,7 +653,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/combined-enum.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/combined-enum.json/default/TopLevel.js index cce650f..31b0193 100644 --- a/base/flow/test/inputs/json/priority/combined-enum.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/combined-enum.json/default/TopLevel.js @@ -145,7 +145,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/direct-recursive.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/direct-recursive.json/default/TopLevel.js index 67ff89d..acd233c 100644 --- a/base/flow/test/inputs/json/priority/direct-recursive.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/direct-recursive.json/default/TopLevel.js @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/empty-enum.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/empty-enum.json/default/TopLevel.js index 084984f..98bfdd8 100644 --- a/base/flow/test/inputs/json/priority/empty-enum.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/empty-enum.json/default/TopLevel.js @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/identifiers.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/identifiers.json/default/TopLevel.js index 8aad518..48da16d 100644 --- a/base/flow/test/inputs/json/priority/identifiers.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/identifiers.json/default/TopLevel.js @@ -166,7 +166,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/issue2680-object-array.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/issue2680-object-array.json/default/TopLevel.js index 0fc960a..ed72dbc 100644 --- a/base/flow/test/inputs/json/priority/issue2680-object-array.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/issue2680-object-array.json/default/TopLevel.js @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/issue2680-scalar-array.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/issue2680-scalar-array.json/default/TopLevel.js index dcbd39d..9a2c339 100644 --- a/base/flow/test/inputs/json/priority/issue2680-scalar-array.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/issue2680-scalar-array.json/default/TopLevel.js @@ -133,7 +133,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/keywords.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/keywords.json/default/TopLevel.js index 276a37b..5bb0301 100644 --- a/base/flow/test/inputs/json/priority/keywords.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/keywords.json/default/TopLevel.js @@ -1560,7 +1560,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/kotlin-enum-class-case-collision.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/kotlin-enum-class-case-collision.json/default/TopLevel.js index 8fa3577..ff467e0 100644 --- a/base/flow/test/inputs/json/priority/kotlin-enum-class-case-collision.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/kotlin-enum-class-case-collision.json/default/TopLevel.js @@ -141,7 +141,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/list.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/list.json/default/TopLevel.js index 2c32b91..447ff4a 100644 --- a/base/flow/test/inputs/json/priority/list.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/list.json/default/TopLevel.js @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/name-style.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/name-style.json/default/TopLevel.js index 3fd7740..b8a8e89 100644 --- a/base/flow/test/inputs/json/priority/name-style.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/name-style.json/default/TopLevel.js @@ -141,7 +141,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/nbl-stats.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/nbl-stats.json/default/TopLevel.js index d54ed07..0213099 100644 --- a/base/flow/test/inputs/json/priority/nbl-stats.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/nbl-stats.json/default/TopLevel.js @@ -467,7 +467,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/nested-objects.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/nested-objects.json/default/TopLevel.js index 9b24cec..f48df76 100644 --- a/base/flow/test/inputs/json/priority/nested-objects.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/nested-objects.json/default/TopLevel.js @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/no-classes.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/no-classes.json/default/TopLevel.js index e911e7a..9bd66d5 100644 --- a/base/flow/test/inputs/json/priority/no-classes.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/no-classes.json/default/TopLevel.js @@ -133,7 +133,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/nst-test-suite.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/nst-test-suite.json/default/TopLevel.js index 315cb72..efc6519 100644 --- a/base/flow/test/inputs/json/priority/nst-test-suite.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/nst-test-suite.json/default/TopLevel.js @@ -275,7 +275,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/number-map.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/number-map.json/default/TopLevel.js index 65a52ce..0455d1a 100644 --- a/base/flow/test/inputs/json/priority/number-map.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/number-map.json/default/TopLevel.js @@ -135,7 +135,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/omit-empty.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/omit-empty.json/default/TopLevel.js index 6b6178b..903de82 100644 --- a/base/flow/test/inputs/json/priority/omit-empty.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/omit-empty.json/default/TopLevel.js @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/optional-union.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/optional-union.json/default/TopLevel.js index e91330a..bb5ab92 100644 --- a/base/flow/test/inputs/json/priority/optional-union.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/optional-union.json/default/TopLevel.js @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/php-mixed-union.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/php-mixed-union.json/default/TopLevel.js index a8eed91..0e39fc6 100644 --- a/base/flow/test/inputs/json/priority/php-mixed-union.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/php-mixed-union.json/default/TopLevel.js @@ -141,7 +141,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/php-validation.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/php-validation.json/default/TopLevel.js index d60e336..8be774a 100644 --- a/base/flow/test/inputs/json/priority/php-validation.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/php-validation.json/default/TopLevel.js @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/recursive.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/recursive.json/default/TopLevel.js index e6ae2a5..65fe913 100644 --- a/base/flow/test/inputs/json/priority/recursive.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/recursive.json/default/TopLevel.js @@ -254,7 +254,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/simple-identifiers.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/simple-identifiers.json/default/TopLevel.js index e89d8d0..d57969b 100644 --- a/base/flow/test/inputs/json/priority/simple-identifiers.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/simple-identifiers.json/default/TopLevel.js @@ -143,7 +143,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/union-constructor-clash.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/union-constructor-clash.json/default/TopLevel.js index 3d399af..31df67f 100644 --- a/base/flow/test/inputs/json/priority/union-constructor-clash.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/union-constructor-clash.json/default/TopLevel.js @@ -142,7 +142,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/unions.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/unions.json/default/TopLevel.js index 09e870e..e188a7c 100644 --- a/base/flow/test/inputs/json/priority/unions.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/unions.json/default/TopLevel.js @@ -145,7 +145,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/url.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/url.json/default/TopLevel.js index e8d9a96..20f95c0 100644 --- a/base/flow/test/inputs/json/priority/url.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/url.json/default/TopLevel.js @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/priority/uuids.json/default/TopLevel.js b/head/flow/test/inputs/json/priority/uuids.json/default/TopLevel.js index bb4e29d..ea407ee 100644 --- a/base/flow/test/inputs/json/priority/uuids.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/priority/uuids.json/default/TopLevel.js @@ -141,7 +141,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (typeof typ === "object") { return typ.hasOwnProperty("uuid") ? typeof val === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(val) ? val : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/samples/bitcoin-block.json/default/TopLevel.js b/head/flow/test/inputs/json/samples/bitcoin-block.json/default/TopLevel.js index 4c8ed85..ce5a641 100644 --- a/base/flow/test/inputs/json/samples/bitcoin-block.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/samples/bitcoin-block.json/default/TopLevel.js @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/samples/copy-with-property.json/default/TopLevel.js b/head/flow/test/inputs/json/samples/copy-with-property.json/default/TopLevel.js index 3c443cc..aff9803 100644 --- a/base/flow/test/inputs/json/samples/copy-with-property.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/samples/copy-with-property.json/default/TopLevel.js @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/samples/getting-started.json/default/TopLevel.js b/head/flow/test/inputs/json/samples/getting-started.json/default/TopLevel.js index ae73cfd..6ea77e9 100644 --- a/base/flow/test/inputs/json/samples/getting-started.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/samples/getting-started.json/default/TopLevel.js @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/samples/github-events.json/default/TopLevel.js b/head/flow/test/inputs/json/samples/github-events.json/default/TopLevel.js index 1d2d9e0..b5d327c 100644 --- a/base/flow/test/inputs/json/samples/github-events.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/samples/github-events.json/default/TopLevel.js @@ -423,7 +423,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/samples/kitchen-sink.json/default/TopLevel.js b/head/flow/test/inputs/json/samples/kitchen-sink.json/default/TopLevel.js index 0d056c0..f31502b 100644 --- a/base/flow/test/inputs/json/samples/kitchen-sink.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/samples/kitchen-sink.json/default/TopLevel.js @@ -167,7 +167,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/samples/null-safe.json/default/TopLevel.js b/head/flow/test/inputs/json/samples/null-safe.json/default/TopLevel.js index c0316c7..4399f87 100644 --- a/base/flow/test/inputs/json/samples/null-safe.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/samples/null-safe.json/default/TopLevel.js @@ -148,7 +148,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/samples/pokedex.json/default/TopLevel.js b/head/flow/test/inputs/json/samples/pokedex.json/default/TopLevel.js index 6ad0269..562138f 100644 --- a/base/flow/test/inputs/json/samples/pokedex.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/samples/pokedex.json/default/TopLevel.js @@ -187,7 +187,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/samples/reddit.json/default/TopLevel.js b/head/flow/test/inputs/json/samples/reddit.json/default/TopLevel.js index 2845c6a..7cf956c 100644 --- a/base/flow/test/inputs/json/samples/reddit.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/samples/reddit.json/default/TopLevel.js @@ -276,7 +276,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/samples/simple-object.json/default/TopLevel.js b/head/flow/test/inputs/json/samples/simple-object.json/default/TopLevel.js index f47044a..f652760 100644 --- a/base/flow/test/inputs/json/samples/simple-object.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/samples/simple-object.json/default/TopLevel.js @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/samples/spotify-album.json/default/TopLevel.js b/head/flow/test/inputs/json/samples/spotify-album.json/default/TopLevel.js index 2ea6b6b..d773ba3 100644 --- a/base/flow/test/inputs/json/samples/spotify-album.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/samples/spotify-album.json/default/TopLevel.js @@ -205,7 +205,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/samples/us-avg-temperatures.json/default/TopLevel.js b/head/flow/test/inputs/json/samples/us-avg-temperatures.json/default/TopLevel.js index ddea840..cdfaa32 100644 --- a/base/flow/test/inputs/json/samples/us-avg-temperatures.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/samples/us-avg-temperatures.json/default/TopLevel.js @@ -148,7 +148,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/flow/test/inputs/json/samples/us-senators.json/default/TopLevel.js b/head/flow/test/inputs/json/samples/us-senators.json/default/TopLevel.js index e14d144..051e481 100644 --- a/base/flow/test/inputs/json/samples/us-senators.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/samples/us-senators.json/default/TopLevel.js @@ -240,7 +240,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-flow/test/inputs/graphql/github1.graphql/default/TopLevel.js b/head/graphql-flow/test/inputs/graphql/github1.graphql/default/TopLevel.js index 6b590a9..51e1098 100644 --- a/base/graphql-flow/test/inputs/graphql/github1.graphql/default/TopLevel.js +++ b/head/graphql-flow/test/inputs/graphql/github1.graphql/default/TopLevel.js @@ -149,7 +149,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-flow/test/inputs/graphql/github2.graphql/default/TopLevel.js b/head/graphql-flow/test/inputs/graphql/github2.graphql/default/TopLevel.js index 8a6c2b5..4e66b84 100644 --- a/base/graphql-flow/test/inputs/graphql/github2.graphql/default/TopLevel.js +++ b/head/graphql-flow/test/inputs/graphql/github2.graphql/default/TopLevel.js @@ -158,7 +158,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-flow/test/inputs/graphql/github3.graphql/default/TopLevel.js b/head/graphql-flow/test/inputs/graphql/github3.graphql/default/TopLevel.js index 87dd299..a435f38 100644 --- a/base/graphql-flow/test/inputs/graphql/github3.graphql/default/TopLevel.js +++ b/head/graphql-flow/test/inputs/graphql/github3.graphql/default/TopLevel.js @@ -166,7 +166,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-flow/test/inputs/graphql/github4.graphql/default/TopLevel.js b/head/graphql-flow/test/inputs/graphql/github4.graphql/default/TopLevel.js index fad899c..a92c640 100644 --- a/base/graphql-flow/test/inputs/graphql/github4.graphql/default/TopLevel.js +++ b/head/graphql-flow/test/inputs/graphql/github4.graphql/default/TopLevel.js @@ -167,7 +167,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-flow/test/inputs/graphql/github5.graphql/default/TopLevel.js b/head/graphql-flow/test/inputs/graphql/github5.graphql/default/TopLevel.js index d45c3af..38b371e 100644 --- a/base/graphql-flow/test/inputs/graphql/github5.graphql/default/TopLevel.js +++ b/head/graphql-flow/test/inputs/graphql/github5.graphql/default/TopLevel.js @@ -149,7 +149,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-flow/test/inputs/graphql/github6.graphql/default/TopLevel.js b/head/graphql-flow/test/inputs/graphql/github6.graphql/default/TopLevel.js index f1587eb..59e92bf 100644 --- a/base/graphql-flow/test/inputs/graphql/github6.graphql/default/TopLevel.js +++ b/head/graphql-flow/test/inputs/graphql/github6.graphql/default/TopLevel.js @@ -149,7 +149,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-flow/test/inputs/graphql/github7.graphql/default/TopLevel.js b/head/graphql-flow/test/inputs/graphql/github7.graphql/default/TopLevel.js index d558b0e..d24e373 100644 --- a/base/graphql-flow/test/inputs/graphql/github7.graphql/default/TopLevel.js +++ b/head/graphql-flow/test/inputs/graphql/github7.graphql/default/TopLevel.js @@ -170,7 +170,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-flow/test/inputs/graphql/github8.graphql/default/TopLevel.js b/head/graphql-flow/test/inputs/graphql/github8.graphql/default/TopLevel.js index 84314c1..e6e1dbf 100644 --- a/base/graphql-flow/test/inputs/graphql/github8.graphql/default/TopLevel.js +++ b/head/graphql-flow/test/inputs/graphql/github8.graphql/default/TopLevel.js @@ -160,7 +160,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-flow/test/inputs/graphql/github9.graphql/default/TopLevel.js b/head/graphql-flow/test/inputs/graphql/github9.graphql/default/TopLevel.js index eb54db1..27dc171 100644 --- a/base/graphql-flow/test/inputs/graphql/github9.graphql/default/TopLevel.js +++ b/head/graphql-flow/test/inputs/graphql/github9.graphql/default/TopLevel.js @@ -167,7 +167,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-javascript/test/inputs/graphql/github1.graphql/default/TopLevel.js b/head/graphql-javascript/test/inputs/graphql/github1.graphql/default/TopLevel.js index cda4faa..725a829 100644 --- a/base/graphql-javascript/test/inputs/graphql/github1.graphql/default/TopLevel.js +++ b/head/graphql-javascript/test/inputs/graphql/github1.graphql/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-javascript/test/inputs/graphql/github2.graphql/default/TopLevel.js b/head/graphql-javascript/test/inputs/graphql/github2.graphql/default/TopLevel.js index d9e41f0..55ecc46 100644 --- a/base/graphql-javascript/test/inputs/graphql/github2.graphql/default/TopLevel.js +++ b/head/graphql-javascript/test/inputs/graphql/github2.graphql/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-javascript/test/inputs/graphql/github3.graphql/default/TopLevel.js b/head/graphql-javascript/test/inputs/graphql/github3.graphql/default/TopLevel.js index b890c1d..cc10a98 100644 --- a/base/graphql-javascript/test/inputs/graphql/github3.graphql/default/TopLevel.js +++ b/head/graphql-javascript/test/inputs/graphql/github3.graphql/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-javascript/test/inputs/graphql/github4.graphql/default/TopLevel.js b/head/graphql-javascript/test/inputs/graphql/github4.graphql/default/TopLevel.js index 48b05ea..5860617 100644 --- a/base/graphql-javascript/test/inputs/graphql/github4.graphql/default/TopLevel.js +++ b/head/graphql-javascript/test/inputs/graphql/github4.graphql/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-javascript/test/inputs/graphql/github5.graphql/default/TopLevel.js b/head/graphql-javascript/test/inputs/graphql/github5.graphql/default/TopLevel.js index 5a1e0ea..d487676 100644 --- a/base/graphql-javascript/test/inputs/graphql/github5.graphql/default/TopLevel.js +++ b/head/graphql-javascript/test/inputs/graphql/github5.graphql/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-javascript/test/inputs/graphql/github6.graphql/default/TopLevel.js b/head/graphql-javascript/test/inputs/graphql/github6.graphql/default/TopLevel.js index a592d63..44cc2dd 100644 --- a/base/graphql-javascript/test/inputs/graphql/github6.graphql/default/TopLevel.js +++ b/head/graphql-javascript/test/inputs/graphql/github6.graphql/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-javascript/test/inputs/graphql/github7.graphql/default/TopLevel.js b/head/graphql-javascript/test/inputs/graphql/github7.graphql/default/TopLevel.js index 9891b62..f133526 100644 --- a/base/graphql-javascript/test/inputs/graphql/github7.graphql/default/TopLevel.js +++ b/head/graphql-javascript/test/inputs/graphql/github7.graphql/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-javascript/test/inputs/graphql/github8.graphql/default/TopLevel.js b/head/graphql-javascript/test/inputs/graphql/github8.graphql/default/TopLevel.js index f280976..1491fd8 100644 --- a/base/graphql-javascript/test/inputs/graphql/github8.graphql/default/TopLevel.js +++ b/head/graphql-javascript/test/inputs/graphql/github8.graphql/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-javascript/test/inputs/graphql/github9.graphql/default/TopLevel.js b/head/graphql-javascript/test/inputs/graphql/github9.graphql/default/TopLevel.js index 1b9771a..ea7e284 100644 --- a/base/graphql-javascript/test/inputs/graphql/github9.graphql/default/TopLevel.js +++ b/head/graphql-javascript/test/inputs/graphql/github9.graphql/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-typescript/test/inputs/graphql/github1.graphql/default/TopLevel.ts b/head/graphql-typescript/test/inputs/graphql/github1.graphql/default/TopLevel.ts index 2247bec..159c145 100644 --- a/base/graphql-typescript/test/inputs/graphql/github1.graphql/default/TopLevel.ts +++ b/head/graphql-typescript/test/inputs/graphql/github1.graphql/default/TopLevel.ts @@ -149,7 +149,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-typescript/test/inputs/graphql/github2.graphql/default/TopLevel.ts b/head/graphql-typescript/test/inputs/graphql/github2.graphql/default/TopLevel.ts index add79a2..f1e8a80 100644 --- a/base/graphql-typescript/test/inputs/graphql/github2.graphql/default/TopLevel.ts +++ b/head/graphql-typescript/test/inputs/graphql/github2.graphql/default/TopLevel.ts @@ -158,7 +158,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-typescript/test/inputs/graphql/github3.graphql/default/TopLevel.ts b/head/graphql-typescript/test/inputs/graphql/github3.graphql/default/TopLevel.ts index b646fd3..616d91c 100644 --- a/base/graphql-typescript/test/inputs/graphql/github3.graphql/default/TopLevel.ts +++ b/head/graphql-typescript/test/inputs/graphql/github3.graphql/default/TopLevel.ts @@ -163,7 +163,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-typescript/test/inputs/graphql/github4.graphql/default/TopLevel.ts b/head/graphql-typescript/test/inputs/graphql/github4.graphql/default/TopLevel.ts index 45d035c..1fec4c6 100644 --- a/base/graphql-typescript/test/inputs/graphql/github4.graphql/default/TopLevel.ts +++ b/head/graphql-typescript/test/inputs/graphql/github4.graphql/default/TopLevel.ts @@ -164,7 +164,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-typescript/test/inputs/graphql/github5.graphql/default/TopLevel.ts b/head/graphql-typescript/test/inputs/graphql/github5.graphql/default/TopLevel.ts index 745f128..81441df 100644 --- a/base/graphql-typescript/test/inputs/graphql/github5.graphql/default/TopLevel.ts +++ b/head/graphql-typescript/test/inputs/graphql/github5.graphql/default/TopLevel.ts @@ -149,7 +149,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-typescript/test/inputs/graphql/github6.graphql/default/TopLevel.ts b/head/graphql-typescript/test/inputs/graphql/github6.graphql/default/TopLevel.ts index 1381ed1..3a83cda 100644 --- a/base/graphql-typescript/test/inputs/graphql/github6.graphql/default/TopLevel.ts +++ b/head/graphql-typescript/test/inputs/graphql/github6.graphql/default/TopLevel.ts @@ -149,7 +149,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-typescript/test/inputs/graphql/github7.graphql/default/TopLevel.ts b/head/graphql-typescript/test/inputs/graphql/github7.graphql/default/TopLevel.ts index d98de7a..747f382 100644 --- a/base/graphql-typescript/test/inputs/graphql/github7.graphql/default/TopLevel.ts +++ b/head/graphql-typescript/test/inputs/graphql/github7.graphql/default/TopLevel.ts @@ -170,7 +170,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-typescript/test/inputs/graphql/github8.graphql/default/TopLevel.ts b/head/graphql-typescript/test/inputs/graphql/github8.graphql/default/TopLevel.ts index d8077bf..08ab69a 100644 --- a/base/graphql-typescript/test/inputs/graphql/github8.graphql/default/TopLevel.ts +++ b/head/graphql-typescript/test/inputs/graphql/github8.graphql/default/TopLevel.ts @@ -158,7 +158,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/graphql-typescript/test/inputs/graphql/github9.graphql/default/TopLevel.ts b/head/graphql-typescript/test/inputs/graphql/github9.graphql/default/TopLevel.ts index 410e31a..215f6b4 100644 --- a/base/graphql-typescript/test/inputs/graphql/github9.graphql/default/TopLevel.ts +++ b/head/graphql-typescript/test/inputs/graphql/github9.graphql/default/TopLevel.ts @@ -161,7 +161,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/00c36.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/00c36.json/default/TopLevel.js index 1eae18f..4b2c4f9 100644 --- a/base/javascript/test/inputs/json/misc/00c36.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/00c36.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/00ec5.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/00ec5.json/default/TopLevel.js index 9e32023..3c9566f 100644 --- a/base/javascript/test/inputs/json/misc/00ec5.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/00ec5.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/010b1.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/010b1.json/default/TopLevel.js index e64053d..53b69dd 100644 --- a/base/javascript/test/inputs/json/misc/010b1.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/010b1.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/016af.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/016af.json/default/TopLevel.js index 7a0802e..7ee1afa 100644 --- a/base/javascript/test/inputs/json/misc/016af.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/016af.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/033b1.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/033b1.json/default/TopLevel.js index c2bf8a2..89e1fca 100644 --- a/base/javascript/test/inputs/json/misc/033b1.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/033b1.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/050b0.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/050b0.json/default/TopLevel.js index 4e4979a..373b95b 100644 --- a/base/javascript/test/inputs/json/misc/050b0.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/050b0.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/06bee.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/06bee.json/default/TopLevel.js index a609a36..828e6ba 100644 --- a/base/javascript/test/inputs/json/misc/06bee.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/06bee.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/07540.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/07540.json/default/TopLevel.js index 13adf5a..afd2b5b 100644 --- a/base/javascript/test/inputs/json/misc/07540.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/07540.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/0779f.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/0779f.json/default/TopLevel.js index 20164df..da96760 100644 --- a/base/javascript/test/inputs/json/misc/0779f.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/0779f.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/07c75.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/07c75.json/default/TopLevel.js index 9e9c2c7..65d48cd 100644 --- a/base/javascript/test/inputs/json/misc/07c75.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/07c75.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/09f54.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/09f54.json/default/TopLevel.js index 279fd7c..2843bb9 100644 --- a/base/javascript/test/inputs/json/misc/09f54.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/09f54.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/0a358.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/0a358.json/default/TopLevel.js index 5ad9544..083096e 100644 --- a/base/javascript/test/inputs/json/misc/0a358.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/0a358.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/0a91a.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/0a91a.json/default/TopLevel.js index 9e6fa01..5a7a624 100644 --- a/base/javascript/test/inputs/json/misc/0a91a.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/0a91a.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/0b91a.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/0b91a.json/default/TopLevel.js index d5f970c..481f39f 100644 --- a/base/javascript/test/inputs/json/misc/0b91a.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/0b91a.json/default/TopLevel.js @@ -130,7 +130,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (typeof typ === "object") { return typ.hasOwnProperty("uuid") ? typeof val === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(val) ? val : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/0cffa.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/0cffa.json/default/TopLevel.js index 6a56fc1..47d638a 100644 --- a/base/javascript/test/inputs/json/misc/0cffa.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/0cffa.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/0e0c2.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/0e0c2.json/default/TopLevel.js index 1c9593e..a9e3980 100644 --- a/base/javascript/test/inputs/json/misc/0e0c2.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/0e0c2.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/0fecf.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/0fecf.json/default/TopLevel.js index 06084a6..cc99ab8 100644 --- a/base/javascript/test/inputs/json/misc/0fecf.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/0fecf.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/10be4.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/10be4.json/default/TopLevel.js index d45deb4..27740c9 100644 --- a/base/javascript/test/inputs/json/misc/10be4.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/10be4.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/112b5.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/112b5.json/default/TopLevel.js index 0907cde..6a82d0d 100644 --- a/base/javascript/test/inputs/json/misc/112b5.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/112b5.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/127a1.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/127a1.json/default/TopLevel.js index 1b0abc9..e5db02c 100644 --- a/base/javascript/test/inputs/json/misc/127a1.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/127a1.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/13d8d.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/13d8d.json/default/TopLevel.js index f9bbbec..b40eb91 100644 --- a/base/javascript/test/inputs/json/misc/13d8d.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/13d8d.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/14d38.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/14d38.json/default/TopLevel.js index e065e77..23d27bd 100644 --- a/base/javascript/test/inputs/json/misc/14d38.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/14d38.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/167d6.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/167d6.json/default/TopLevel.js index c2bf8a2..89e1fca 100644 --- a/base/javascript/test/inputs/json/misc/167d6.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/167d6.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/16bc5.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/16bc5.json/default/TopLevel.js index afb1626..8797717 100644 --- a/base/javascript/test/inputs/json/misc/16bc5.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/16bc5.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/176f1.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/176f1.json/default/TopLevel.js index 3a8ec95..8bba887 100644 --- a/base/javascript/test/inputs/json/misc/176f1.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/176f1.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/1a7f5.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/1a7f5.json/default/TopLevel.js index e64053d..53b69dd 100644 --- a/base/javascript/test/inputs/json/misc/1a7f5.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/1a7f5.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/1b28c.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/1b28c.json/default/TopLevel.js index 7a0802e..7ee1afa 100644 --- a/base/javascript/test/inputs/json/misc/1b28c.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/1b28c.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/1b409.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/1b409.json/default/TopLevel.js index 7f3ffca..5110389 100644 --- a/base/javascript/test/inputs/json/misc/1b409.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/1b409.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/2465e.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/2465e.json/default/TopLevel.js index 3bb6b93..376b62d 100644 --- a/base/javascript/test/inputs/json/misc/2465e.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/2465e.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/24f52.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/24f52.json/default/TopLevel.js index 20164df..da96760 100644 --- a/base/javascript/test/inputs/json/misc/24f52.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/24f52.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/262f0.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/262f0.json/default/TopLevel.js index f83a5b8..463d597 100644 --- a/base/javascript/test/inputs/json/misc/262f0.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/262f0.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/26b49.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/26b49.json/default/TopLevel.js index 1e547a4..1450c3f 100644 --- a/base/javascript/test/inputs/json/misc/26b49.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/26b49.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/26c9c.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/26c9c.json/default/TopLevel.js index 98b4900..4d67ea6 100644 --- a/base/javascript/test/inputs/json/misc/26c9c.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/26c9c.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/27332.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/27332.json/default/TopLevel.js index bd50ce7..3f5ae6d 100644 --- a/base/javascript/test/inputs/json/misc/27332.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/27332.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/29f47.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/29f47.json/default/TopLevel.js index 537f6fc..313fb29 100644 --- a/base/javascript/test/inputs/json/misc/29f47.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/29f47.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/2d4e2.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/2d4e2.json/default/TopLevel.js index 90d7480..f8f6a2e 100644 --- a/base/javascript/test/inputs/json/misc/2d4e2.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/2d4e2.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/2df80.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/2df80.json/default/TopLevel.js index 323ece6..cdbc58a 100644 --- a/base/javascript/test/inputs/json/misc/2df80.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/2df80.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/31189.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/31189.json/default/TopLevel.js index e0faa70..843e350 100644 --- a/base/javascript/test/inputs/json/misc/31189.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/31189.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/32431.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/32431.json/default/TopLevel.js index a5ba9e5..5a4dd01 100644 --- a/base/javascript/test/inputs/json/misc/32431.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/32431.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/32d5c.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/32d5c.json/default/TopLevel.js index 6c782c0..cd11a95 100644 --- a/base/javascript/test/inputs/json/misc/32d5c.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/32d5c.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/337ed.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/337ed.json/default/TopLevel.js index 4bf3dd5..7ca3440 100644 --- a/base/javascript/test/inputs/json/misc/337ed.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/337ed.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/33d2e.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/33d2e.json/default/TopLevel.js index fab6bdf..3a01f28 100644 --- a/base/javascript/test/inputs/json/misc/33d2e.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/33d2e.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/34702.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/34702.json/default/TopLevel.js index eb2719c..a9b3fbf 100644 --- a/base/javascript/test/inputs/json/misc/34702.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/34702.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/3536b.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/3536b.json/default/TopLevel.js index 6a734f2..7b27507 100644 --- a/base/javascript/test/inputs/json/misc/3536b.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/3536b.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/3659d.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/3659d.json/default/TopLevel.js index 7a0802e..7ee1afa 100644 --- a/base/javascript/test/inputs/json/misc/3659d.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/3659d.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/36d5d.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/36d5d.json/default/TopLevel.js index 20164df..da96760 100644 --- a/base/javascript/test/inputs/json/misc/36d5d.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/36d5d.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/3a6b3.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/3a6b3.json/default/TopLevel.js index 20164df..da96760 100644 --- a/base/javascript/test/inputs/json/misc/3a6b3.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/3a6b3.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/3e9a3.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/3e9a3.json/default/TopLevel.js index 3a8ec95..8bba887 100644 --- a/base/javascript/test/inputs/json/misc/3e9a3.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/3e9a3.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/3f1ce.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/3f1ce.json/default/TopLevel.js index 0ce7d8b..5a00c63 100644 --- a/base/javascript/test/inputs/json/misc/3f1ce.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/3f1ce.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/421d4.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/421d4.json/default/TopLevel.js index 3087b59..76fd39f 100644 --- a/base/javascript/test/inputs/json/misc/421d4.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/421d4.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/437e7.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/437e7.json/default/TopLevel.js index f7e3060..a3749cf 100644 --- a/base/javascript/test/inputs/json/misc/437e7.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/437e7.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/43970.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/43970.json/default/TopLevel.js index 63e3bb0..8e2aeb1 100644 --- a/base/javascript/test/inputs/json/misc/43970.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/43970.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/43eaf.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/43eaf.json/default/TopLevel.js index c2bf8a2..89e1fca 100644 --- a/base/javascript/test/inputs/json/misc/43eaf.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/43eaf.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/458db.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/458db.json/default/TopLevel.js index a3db007..fe9dcb7 100644 --- a/base/javascript/test/inputs/json/misc/458db.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/458db.json/default/TopLevel.js @@ -130,7 +130,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (typeof typ === "object") { return typ.hasOwnProperty("uuid") ? typeof val === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(val) ? val : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/4961a.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/4961a.json/default/TopLevel.js index 7a0802e..7ee1afa 100644 --- a/base/javascript/test/inputs/json/misc/4961a.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/4961a.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/4a0d7.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/4a0d7.json/default/TopLevel.js index 7a0802e..7ee1afa 100644 --- a/base/javascript/test/inputs/json/misc/4a0d7.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/4a0d7.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/4a455.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/4a455.json/default/TopLevel.js index da2d3a9..d265bae 100644 --- a/base/javascript/test/inputs/json/misc/4a455.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/4a455.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/4c547.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/4c547.json/default/TopLevel.js index afb1626..8797717 100644 --- a/base/javascript/test/inputs/json/misc/4c547.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/4c547.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/4d6fb.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/4d6fb.json/default/TopLevel.js index 9381577..21d6b23 100644 --- a/base/javascript/test/inputs/json/misc/4d6fb.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/4d6fb.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/4e336.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/4e336.json/default/TopLevel.js index 7a0802e..7ee1afa 100644 --- a/base/javascript/test/inputs/json/misc/4e336.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/4e336.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/54147.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/54147.json/default/TopLevel.js index ce9bcb8..38c1e17 100644 --- a/base/javascript/test/inputs/json/misc/54147.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/54147.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/54d32.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/54d32.json/default/TopLevel.js index dd62ee9..d952f1e 100644 --- a/base/javascript/test/inputs/json/misc/54d32.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/54d32.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/570ec.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/570ec.json/default/TopLevel.js index 2c51906..b1bd14a 100644 --- a/base/javascript/test/inputs/json/misc/570ec.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/570ec.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/5dd0d.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/5dd0d.json/default/TopLevel.js index 20164df..da96760 100644 --- a/base/javascript/test/inputs/json/misc/5dd0d.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/5dd0d.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/5eae5.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/5eae5.json/default/TopLevel.js index 8a34709..9abaa2b 100644 --- a/base/javascript/test/inputs/json/misc/5eae5.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/5eae5.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/5eb20.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/5eb20.json/default/TopLevel.js index 20164df..da96760 100644 --- a/base/javascript/test/inputs/json/misc/5eb20.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/5eb20.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/5f3a1.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/5f3a1.json/default/TopLevel.js index c2bf8a2..89e1fca 100644 --- a/base/javascript/test/inputs/json/misc/5f3a1.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/5f3a1.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/5f7fe.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/5f7fe.json/default/TopLevel.js index 51f75c1..7e8756d 100644 --- a/base/javascript/test/inputs/json/misc/5f7fe.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/5f7fe.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/617e8.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/617e8.json/default/TopLevel.js index 46af6d4..09c6030 100644 --- a/base/javascript/test/inputs/json/misc/617e8.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/617e8.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/61b66.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/61b66.json/default/TopLevel.js index 20164df..da96760 100644 --- a/base/javascript/test/inputs/json/misc/61b66.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/61b66.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/6260a.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/6260a.json/default/TopLevel.js index c2bf8a2..89e1fca 100644 --- a/base/javascript/test/inputs/json/misc/6260a.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/6260a.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/65dec.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/65dec.json/default/TopLevel.js index daf81e6..390ffdd 100644 --- a/base/javascript/test/inputs/json/misc/65dec.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/65dec.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/66121.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/66121.json/default/TopLevel.js index 897495b..cae28e1 100644 --- a/base/javascript/test/inputs/json/misc/66121.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/66121.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/6617c.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/6617c.json/default/TopLevel.js index d1a5b8f..504057f 100644 --- a/base/javascript/test/inputs/json/misc/6617c.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/6617c.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/67c03.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/67c03.json/default/TopLevel.js index c6ac0db..b633061 100644 --- a/base/javascript/test/inputs/json/misc/67c03.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/67c03.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/68c30.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/68c30.json/default/TopLevel.js index 79ad361..b847771 100644 --- a/base/javascript/test/inputs/json/misc/68c30.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/68c30.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/6c155.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/6c155.json/default/TopLevel.js index 9916bf3..d59fc42 100644 --- a/base/javascript/test/inputs/json/misc/6c155.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/6c155.json/default/TopLevel.js @@ -130,7 +130,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (typeof typ === "object") { return typ.hasOwnProperty("uuid") ? typeof val === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(val) ? val : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/6de06.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/6de06.json/default/TopLevel.js index 0dbcd3a..83856f6 100644 --- a/base/javascript/test/inputs/json/misc/6de06.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/6de06.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/6dec6.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/6dec6.json/default/TopLevel.js index f16135c..a96a8ab 100644 --- a/base/javascript/test/inputs/json/misc/6dec6.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/6dec6.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/6eb00.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/6eb00.json/default/TopLevel.js index edb0a76..7146a38 100644 --- a/base/javascript/test/inputs/json/misc/6eb00.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/6eb00.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/70c77.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/70c77.json/default/TopLevel.js index c2bf8a2..89e1fca 100644 --- a/base/javascript/test/inputs/json/misc/70c77.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/70c77.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/734ad.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/734ad.json/default/TopLevel.js index 8d56333..673e18b 100644 --- a/base/javascript/test/inputs/json/misc/734ad.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/734ad.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/75912.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/75912.json/default/TopLevel.js index c2bf8a2..89e1fca 100644 --- a/base/javascript/test/inputs/json/misc/75912.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/75912.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/7681c.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/7681c.json/default/TopLevel.js index 9e1c26e..0a61b51 100644 --- a/base/javascript/test/inputs/json/misc/7681c.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/7681c.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/76ae1.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/76ae1.json/default/TopLevel.js index c6b5f7a..3d7f7fc 100644 --- a/base/javascript/test/inputs/json/misc/76ae1.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/76ae1.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/77392.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/77392.json/default/TopLevel.js index 27ee60a..4399f9f 100644 --- a/base/javascript/test/inputs/json/misc/77392.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/77392.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/7d397.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/7d397.json/default/TopLevel.js index 4f6d19f..7e2532d 100644 --- a/base/javascript/test/inputs/json/misc/7d397.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/7d397.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/7d722.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/7d722.json/default/TopLevel.js index 20164df..da96760 100644 --- a/base/javascript/test/inputs/json/misc/7d722.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/7d722.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/7df41.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/7df41.json/default/TopLevel.js index 2a78be1..72704b6 100644 --- a/base/javascript/test/inputs/json/misc/7df41.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/7df41.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/7dfa6.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/7dfa6.json/default/TopLevel.js index 7a0802e..7ee1afa 100644 --- a/base/javascript/test/inputs/json/misc/7dfa6.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/7dfa6.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/7eb30.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/7eb30.json/default/TopLevel.js index 7b0c6cf..6816e49 100644 --- a/base/javascript/test/inputs/json/misc/7eb30.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/7eb30.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/7f568.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/7f568.json/default/TopLevel.js index ad3307c..aff2371 100644 --- a/base/javascript/test/inputs/json/misc/7f568.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/7f568.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/7fbfb.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/7fbfb.json/default/TopLevel.js index aaf3a07..4f77542 100644 --- a/base/javascript/test/inputs/json/misc/7fbfb.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/7fbfb.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/80aff.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/80aff.json/default/TopLevel.js index 18f5b39..89a6010 100644 --- a/base/javascript/test/inputs/json/misc/80aff.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/80aff.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/82509.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/82509.json/default/TopLevel.js index 5938abf..bd8181d 100644 --- a/base/javascript/test/inputs/json/misc/82509.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/82509.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/8592b.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/8592b.json/default/TopLevel.js index 2f6c40e..fe36f3c 100644 --- a/base/javascript/test/inputs/json/misc/8592b.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/8592b.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/88130.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/88130.json/default/TopLevel.js index afb1626..8797717 100644 --- a/base/javascript/test/inputs/json/misc/88130.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/88130.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/8a62c.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/8a62c.json/default/TopLevel.js index 7a0802e..7ee1afa 100644 --- a/base/javascript/test/inputs/json/misc/8a62c.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/8a62c.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/908db.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/908db.json/default/TopLevel.js index a52338b..8fb94d1 100644 --- a/base/javascript/test/inputs/json/misc/908db.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/908db.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/9617f.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/9617f.json/default/TopLevel.js index c2bf8a2..89e1fca 100644 --- a/base/javascript/test/inputs/json/misc/9617f.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/9617f.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/96f7c.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/96f7c.json/default/TopLevel.js index 77acd06..3bb3064 100644 --- a/base/javascript/test/inputs/json/misc/96f7c.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/96f7c.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/9847b.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/9847b.json/default/TopLevel.js index 6b6a39c..ed30824 100644 --- a/base/javascript/test/inputs/json/misc/9847b.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/9847b.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/9929c.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/9929c.json/default/TopLevel.js index afb1626..8797717 100644 --- a/base/javascript/test/inputs/json/misc/9929c.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/9929c.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/996bd.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/996bd.json/default/TopLevel.js index 9b5b5ab..2eecf7e 100644 --- a/base/javascript/test/inputs/json/misc/996bd.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/996bd.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/9a503.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/9a503.json/default/TopLevel.js index 4fa553a..289b33a 100644 --- a/base/javascript/test/inputs/json/misc/9a503.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/9a503.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/9ac3b.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/9ac3b.json/default/TopLevel.js index c38f1ea..c725e75 100644 --- a/base/javascript/test/inputs/json/misc/9ac3b.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/9ac3b.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/9eed5.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/9eed5.json/default/TopLevel.js index 3f82480..3daf645 100644 --- a/base/javascript/test/inputs/json/misc/9eed5.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/9eed5.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/a0496.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/a0496.json/default/TopLevel.js index d4a2b7d..dedc844 100644 --- a/base/javascript/test/inputs/json/misc/a0496.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/a0496.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/a1eca.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/a1eca.json/default/TopLevel.js index afb1626..8797717 100644 --- a/base/javascript/test/inputs/json/misc/a1eca.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/a1eca.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/a3d8c.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/a3d8c.json/default/TopLevel.js index ff1ec44..b981cae 100644 --- a/base/javascript/test/inputs/json/misc/a3d8c.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/a3d8c.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/a45b0.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/a45b0.json/default/TopLevel.js index e64053d..53b69dd 100644 --- a/base/javascript/test/inputs/json/misc/a45b0.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/a45b0.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/a71df.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/a71df.json/default/TopLevel.js index 20164df..da96760 100644 --- a/base/javascript/test/inputs/json/misc/a71df.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/a71df.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/a9691.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/a9691.json/default/TopLevel.js index c2bf8a2..89e1fca 100644 --- a/base/javascript/test/inputs/json/misc/a9691.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/a9691.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/ab0d1.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/ab0d1.json/default/TopLevel.js index e64053d..53b69dd 100644 --- a/base/javascript/test/inputs/json/misc/ab0d1.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/ab0d1.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/abb4b.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/abb4b.json/default/TopLevel.js index 7a0802e..7ee1afa 100644 --- a/base/javascript/test/inputs/json/misc/abb4b.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/abb4b.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/ac944.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/ac944.json/default/TopLevel.js index c2bf8a2..89e1fca 100644 --- a/base/javascript/test/inputs/json/misc/ac944.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/ac944.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/ad8be.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/ad8be.json/default/TopLevel.js index d45deb4..27740c9 100644 --- a/base/javascript/test/inputs/json/misc/ad8be.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/ad8be.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/ae7f0.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/ae7f0.json/default/TopLevel.js index b715117..b1f12f9 100644 --- a/base/javascript/test/inputs/json/misc/ae7f0.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/ae7f0.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/ae9ca.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/ae9ca.json/default/TopLevel.js index c649d88..399c60e 100644 --- a/base/javascript/test/inputs/json/misc/ae9ca.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/ae9ca.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/af2d1.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/af2d1.json/default/TopLevel.js index 9d7e65f..7fbbeb2 100644 --- a/base/javascript/test/inputs/json/misc/af2d1.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/af2d1.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/b4865.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/b4865.json/default/TopLevel.js index 5586f38..5a5f316 100644 --- a/base/javascript/test/inputs/json/misc/b4865.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/b4865.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/b6f2c.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/b6f2c.json/default/TopLevel.js index 7a0802e..7ee1afa 100644 --- a/base/javascript/test/inputs/json/misc/b6f2c.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/b6f2c.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/b6fe5.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/b6fe5.json/default/TopLevel.js index 7120acd..4bdc039 100644 --- a/base/javascript/test/inputs/json/misc/b6fe5.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/b6fe5.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/b9f64.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/b9f64.json/default/TopLevel.js index d19e1b4..a049de5 100644 --- a/base/javascript/test/inputs/json/misc/b9f64.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/b9f64.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/bb1ec.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/bb1ec.json/default/TopLevel.js index 7a0802e..7ee1afa 100644 --- a/base/javascript/test/inputs/json/misc/bb1ec.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/bb1ec.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/be234.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/be234.json/default/TopLevel.js index f368bb2..13394f6 100644 --- a/base/javascript/test/inputs/json/misc/be234.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/be234.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/c0356.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/c0356.json/default/TopLevel.js index 87bdad7..18bdd7d 100644 --- a/base/javascript/test/inputs/json/misc/c0356.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/c0356.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/c0a3a.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/c0a3a.json/default/TopLevel.js index 20164df..da96760 100644 --- a/base/javascript/test/inputs/json/misc/c0a3a.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/c0a3a.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/c3303.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/c3303.json/default/TopLevel.js index 9d3f83b..642a6e1 100644 --- a/base/javascript/test/inputs/json/misc/c3303.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/c3303.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/c6cfd.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/c6cfd.json/default/TopLevel.js index bcb31f7..5bce032 100644 --- a/base/javascript/test/inputs/json/misc/c6cfd.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/c6cfd.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/c8c7e.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/c8c7e.json/default/TopLevel.js index 21f2218..b9db820 100644 --- a/base/javascript/test/inputs/json/misc/c8c7e.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/c8c7e.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/cb0cc.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/cb0cc.json/default/TopLevel.js index 2e9ec77..ed3e4af 100644 --- a/base/javascript/test/inputs/json/misc/cb0cc.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/cb0cc.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/cb81e.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/cb81e.json/default/TopLevel.js index e751afc..93fec62 100644 --- a/base/javascript/test/inputs/json/misc/cb81e.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/cb81e.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/ccd18.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/ccd18.json/default/TopLevel.js index 20164df..da96760 100644 --- a/base/javascript/test/inputs/json/misc/ccd18.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/ccd18.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/cd238.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/cd238.json/default/TopLevel.js index 20164df..da96760 100644 --- a/base/javascript/test/inputs/json/misc/cd238.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/cd238.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/cd463.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/cd463.json/default/TopLevel.js index c2bf8a2..89e1fca 100644 --- a/base/javascript/test/inputs/json/misc/cd463.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/cd463.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/cda6c.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/cda6c.json/default/TopLevel.js index 03d1c1d..56080be 100644 --- a/base/javascript/test/inputs/json/misc/cda6c.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/cda6c.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/cf0d8.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/cf0d8.json/default/TopLevel.js index afb1626..8797717 100644 --- a/base/javascript/test/inputs/json/misc/cf0d8.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/cf0d8.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/cfbce.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/cfbce.json/default/TopLevel.js index c2bf8a2..89e1fca 100644 --- a/base/javascript/test/inputs/json/misc/cfbce.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/cfbce.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/d0908.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/d0908.json/default/TopLevel.js index 7a0802e..7ee1afa 100644 --- a/base/javascript/test/inputs/json/misc/d0908.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/d0908.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/d23d5.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/d23d5.json/default/TopLevel.js index 81e452e..6ea2cd8 100644 --- a/base/javascript/test/inputs/json/misc/d23d5.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/d23d5.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/dbfb3.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/dbfb3.json/default/TopLevel.js index 7368b7f..f3d5f27 100644 --- a/base/javascript/test/inputs/json/misc/dbfb3.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/dbfb3.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/dc44f.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/dc44f.json/default/TopLevel.js index f2e6090..329bbfc 100644 --- a/base/javascript/test/inputs/json/misc/dc44f.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/dc44f.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/dd1ce.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/dd1ce.json/default/TopLevel.js index f2e6090..329bbfc 100644 --- a/base/javascript/test/inputs/json/misc/dd1ce.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/dd1ce.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/dec3a.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/dec3a.json/default/TopLevel.js index 7747c5e..c49d1f6 100644 --- a/base/javascript/test/inputs/json/misc/dec3a.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/dec3a.json/default/TopLevel.js @@ -130,7 +130,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (typeof typ === "object") { return typ.hasOwnProperty("uuid") ? typeof val === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(val) ? val : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/df957.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/df957.json/default/TopLevel.js index afb1626..8797717 100644 --- a/base/javascript/test/inputs/json/misc/df957.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/df957.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/e0ac7.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/e0ac7.json/default/TopLevel.js index d4188ed..47d3552 100644 --- a/base/javascript/test/inputs/json/misc/e0ac7.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/e0ac7.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/e2915.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/e2915.json/default/TopLevel.js index 65548c1..de5c087 100644 --- a/base/javascript/test/inputs/json/misc/e2915.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/e2915.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/e2a58.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/e2a58.json/default/TopLevel.js index 0284dca..b6e2a6c 100644 --- a/base/javascript/test/inputs/json/misc/e2a58.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/e2a58.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/e324e.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/e324e.json/default/TopLevel.js index 0cb2754..744eeb6 100644 --- a/base/javascript/test/inputs/json/misc/e324e.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/e324e.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/e53b5.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/e53b5.json/default/TopLevel.js index e5f4f15..8b8220e 100644 --- a/base/javascript/test/inputs/json/misc/e53b5.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/e53b5.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/e64a0.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/e64a0.json/default/TopLevel.js index 0907cde..6a82d0d 100644 --- a/base/javascript/test/inputs/json/misc/e64a0.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/e64a0.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/e8a0b.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/e8a0b.json/default/TopLevel.js index e64053d..53b69dd 100644 --- a/base/javascript/test/inputs/json/misc/e8a0b.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/e8a0b.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/e8b04.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/e8b04.json/default/TopLevel.js index c7533ba..edc9042 100644 --- a/base/javascript/test/inputs/json/misc/e8b04.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/e8b04.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/ed095.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/ed095.json/default/TopLevel.js index d549e25..d21c253 100644 --- a/base/javascript/test/inputs/json/misc/ed095.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/ed095.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/f22f5.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/f22f5.json/default/TopLevel.js index ad65f03..fecd30e 100644 --- a/base/javascript/test/inputs/json/misc/f22f5.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/f22f5.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/f3139.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/f3139.json/default/TopLevel.js index 6b6a39c..ed30824 100644 --- a/base/javascript/test/inputs/json/misc/f3139.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/f3139.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/f3edf.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/f3edf.json/default/TopLevel.js index e64053d..53b69dd 100644 --- a/base/javascript/test/inputs/json/misc/f3edf.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/f3edf.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/f466a.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/f466a.json/default/TopLevel.js index e64053d..53b69dd 100644 --- a/base/javascript/test/inputs/json/misc/f466a.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/f466a.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/f6a65.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/f6a65.json/default/TopLevel.js index ccae6a8..edfd4a6 100644 --- a/base/javascript/test/inputs/json/misc/f6a65.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/f6a65.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/f74d5.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/f74d5.json/default/TopLevel.js index 48fadf8..b17e3f0 100644 --- a/base/javascript/test/inputs/json/misc/f74d5.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/f74d5.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/f82d9.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/f82d9.json/default/TopLevel.js index 59f4135..9e4fb5d 100644 --- a/base/javascript/test/inputs/json/misc/f82d9.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/f82d9.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/f974d.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/f974d.json/default/TopLevel.js index 6cf685b..fb5d5ee 100644 --- a/base/javascript/test/inputs/json/misc/f974d.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/f974d.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/faff5.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/faff5.json/default/TopLevel.js index 9239186..1279f15 100644 --- a/base/javascript/test/inputs/json/misc/faff5.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/faff5.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/fcca3.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/fcca3.json/default/TopLevel.js index 9c92f34..7ecd4eb 100644 --- a/base/javascript/test/inputs/json/misc/fcca3.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/fcca3.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/misc/fd329.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/fd329.json/default/TopLevel.js index 279fd7c..2843bb9 100644 --- a/base/javascript/test/inputs/json/misc/fd329.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/fd329.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/blns-object.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/blns-object.json/default/TopLevel.js index 29e830b..6882164 100644 --- a/base/javascript/test/inputs/json/priority/blns-object.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/blns-object.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/bug2037.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/bug2037.json/default/TopLevel.js index e84c605..ec05c5f 100644 --- a/base/javascript/test/inputs/json/priority/bug2037.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/bug2037.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/bug2521.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/bug2521.json/default/TopLevel.js index 052eabb..9d60567 100644 --- a/base/javascript/test/inputs/json/priority/bug2521.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/bug2521.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/bug2590.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/bug2590.json/default/TopLevel.js index 41c99a0..5875410 100644 --- a/base/javascript/test/inputs/json/priority/bug2590.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/bug2590.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/bug2663.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/bug2663.json/default/TopLevel.js index c9e36dc..8b9499e 100644 --- a/base/javascript/test/inputs/json/priority/bug2663.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/bug2663.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/bug2793.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/bug2793.json/default/TopLevel.js index 1811c1d..fac9b8e 100644 --- a/base/javascript/test/inputs/json/priority/bug2793.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/bug2793.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/bug427.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/bug427.json/default/TopLevel.js index be4743b..9006bd4 100644 --- a/base/javascript/test/inputs/json/priority/bug427.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/bug427.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/bug790.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/bug790.json/default/TopLevel.js index 3718ca1..2dd183e 100644 --- a/base/javascript/test/inputs/json/priority/bug790.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/bug790.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/bug855-short.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/bug855-short.json/default/TopLevel.js index 60500f3..7d6cf13 100644 --- a/base/javascript/test/inputs/json/priority/bug855-short.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/bug855-short.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/bug863.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/bug863.json/default/TopLevel.js index eb29de3..cc6a9e5 100644 --- a/base/javascript/test/inputs/json/priority/bug863.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/bug863.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/coin-pairs.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/coin-pairs.json/default/TopLevel.js index 14a4e26..0ca4b6d 100644 --- a/base/javascript/test/inputs/json/priority/coin-pairs.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/coin-pairs.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/combinations1.json/converters-top-level--67aa452ed509/TopLevel.js b/head/javascript/test/inputs/json/priority/combinations1.json/converters-top-level--67aa452ed509/TopLevel.js index 05a2053..88d564a 100644 --- a/base/javascript/test/inputs/json/priority/combinations1.json/converters-top-level--67aa452ed509/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/combinations1.json/converters-top-level--67aa452ed509/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/combinations1.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/combinations1.json/default/TopLevel.js index 05a2053..88d564a 100644 --- a/base/javascript/test/inputs/json/priority/combinations1.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/combinations1.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/combinations1.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js b/head/javascript/test/inputs/json/priority/combinations1.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js index f821b60..44655c4 100644 --- a/base/javascript/test/inputs/json/priority/combinations1.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/combinations1.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/combinations2.json/converters-top-level--67aa452ed509/TopLevel.js b/head/javascript/test/inputs/json/priority/combinations2.json/converters-top-level--67aa452ed509/TopLevel.js index 7608c68..8e794cc 100644 --- a/base/javascript/test/inputs/json/priority/combinations2.json/converters-top-level--67aa452ed509/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/combinations2.json/converters-top-level--67aa452ed509/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/combinations2.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/combinations2.json/default/TopLevel.js index 7608c68..8e794cc 100644 --- a/base/javascript/test/inputs/json/priority/combinations2.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/combinations2.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/combinations2.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js b/head/javascript/test/inputs/json/priority/combinations2.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js index 0ab0ca9..3d12c61 100644 --- a/base/javascript/test/inputs/json/priority/combinations2.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/combinations2.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/combinations3.json/converters-top-level--67aa452ed509/TopLevel.js b/head/javascript/test/inputs/json/priority/combinations3.json/converters-top-level--67aa452ed509/TopLevel.js index 8485c3e..fb2f1c3 100644 --- a/base/javascript/test/inputs/json/priority/combinations3.json/converters-top-level--67aa452ed509/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/combinations3.json/converters-top-level--67aa452ed509/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/combinations3.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/combinations3.json/default/TopLevel.js index 8485c3e..fb2f1c3 100644 --- a/base/javascript/test/inputs/json/priority/combinations3.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/combinations3.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/combinations3.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js b/head/javascript/test/inputs/json/priority/combinations3.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js index 4d6733e..624456d 100644 --- a/base/javascript/test/inputs/json/priority/combinations3.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/combinations3.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/combinations4.json/converters-top-level--67aa452ed509/TopLevel.js b/head/javascript/test/inputs/json/priority/combinations4.json/converters-top-level--67aa452ed509/TopLevel.js index c952b8d..ca6ffde 100644 --- a/base/javascript/test/inputs/json/priority/combinations4.json/converters-top-level--67aa452ed509/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/combinations4.json/converters-top-level--67aa452ed509/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/combinations4.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/combinations4.json/default/TopLevel.js index c952b8d..ca6ffde 100644 --- a/base/javascript/test/inputs/json/priority/combinations4.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/combinations4.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/combinations4.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js b/head/javascript/test/inputs/json/priority/combinations4.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js index ea2b74f..4f8e19a 100644 --- a/base/javascript/test/inputs/json/priority/combinations4.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/combinations4.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/combined-enum.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/combined-enum.json/default/TopLevel.js index e5c755c..e6e4381 100644 --- a/base/javascript/test/inputs/json/priority/combined-enum.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/combined-enum.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/direct-recursive.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/direct-recursive.json/default/TopLevel.js index 892673a..8ecc199 100644 --- a/base/javascript/test/inputs/json/priority/direct-recursive.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/direct-recursive.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/empty-enum.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/empty-enum.json/default/TopLevel.js index f2cccf7..e092e28 100644 --- a/base/javascript/test/inputs/json/priority/empty-enum.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/empty-enum.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/identifiers.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/identifiers.json/default/TopLevel.js index f5979d9..9df1554 100644 --- a/base/javascript/test/inputs/json/priority/identifiers.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/identifiers.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/issue2680-object-array.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/issue2680-object-array.json/default/TopLevel.js index dafae68..658f4ef 100644 --- a/base/javascript/test/inputs/json/priority/issue2680-object-array.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/issue2680-object-array.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/issue2680-scalar-array.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/issue2680-scalar-array.json/default/TopLevel.js index bbf1861..ca3c226 100644 --- a/base/javascript/test/inputs/json/priority/issue2680-scalar-array.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/issue2680-scalar-array.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/keywords.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/keywords.json/default/TopLevel.js index cbfaf42..1f5ef6b 100644 --- a/base/javascript/test/inputs/json/priority/keywords.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/keywords.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/kotlin-enum-class-case-collision.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/kotlin-enum-class-case-collision.json/default/TopLevel.js index 372328c..9ea4f82 100644 --- a/base/javascript/test/inputs/json/priority/kotlin-enum-class-case-collision.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/kotlin-enum-class-case-collision.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/list.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/list.json/default/TopLevel.js index f3d2721..ca51b35 100644 --- a/base/javascript/test/inputs/json/priority/list.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/list.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/name-style.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/name-style.json/default/TopLevel.js index d60d428..125a6f4 100644 --- a/base/javascript/test/inputs/json/priority/name-style.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/name-style.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/nbl-stats.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/nbl-stats.json/default/TopLevel.js index 9b555c5..e7ab3c3 100644 --- a/base/javascript/test/inputs/json/priority/nbl-stats.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/nbl-stats.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/nested-objects.json/converters-all-objects--3a443babd1cb/TopLevel.js b/head/javascript/test/inputs/json/priority/nested-objects.json/converters-all-objects--3a443babd1cb/TopLevel.js index 222f6ec..cfd27e9 100644 --- a/base/javascript/test/inputs/json/priority/nested-objects.json/converters-all-objects--3a443babd1cb/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/nested-objects.json/converters-all-objects--3a443babd1cb/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/nested-objects.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/nested-objects.json/default/TopLevel.js index 222f6ec..cfd27e9 100644 --- a/base/javascript/test/inputs/json/priority/nested-objects.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/nested-objects.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/no-classes.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/no-classes.json/default/TopLevel.js index 597cc0e..0616383 100644 --- a/base/javascript/test/inputs/json/priority/no-classes.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/no-classes.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/nst-test-suite.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/nst-test-suite.json/default/TopLevel.js index f21c58c..c5d2a33 100644 --- a/base/javascript/test/inputs/json/priority/nst-test-suite.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/nst-test-suite.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/number-map.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/number-map.json/default/TopLevel.js index b4c8d4b..785b69f 100644 --- a/base/javascript/test/inputs/json/priority/number-map.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/number-map.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/omit-empty.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/omit-empty.json/default/TopLevel.js index f106da1..29d5144 100644 --- a/base/javascript/test/inputs/json/priority/omit-empty.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/omit-empty.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/optional-union.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/optional-union.json/default/TopLevel.js index 4be82c8..df58b18 100644 --- a/base/javascript/test/inputs/json/priority/optional-union.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/optional-union.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/php-mixed-union.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/php-mixed-union.json/default/TopLevel.js index cd66066..459f483 100644 --- a/base/javascript/test/inputs/json/priority/php-mixed-union.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/php-mixed-union.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/php-validation.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/php-validation.json/default/TopLevel.js index 86467b0..44deb53 100644 --- a/base/javascript/test/inputs/json/priority/php-validation.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/php-validation.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/recursive.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/recursive.json/default/TopLevel.js index 04ade36..7c73e2f 100644 --- a/base/javascript/test/inputs/json/priority/recursive.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/recursive.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/simple-identifiers.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/simple-identifiers.json/default/TopLevel.js index cbcccb7..25ceaf8 100644 --- a/base/javascript/test/inputs/json/priority/simple-identifiers.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/simple-identifiers.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/union-constructor-clash.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/union-constructor-clash.json/default/TopLevel.js index e1fc92a..3cfd3d7 100644 --- a/base/javascript/test/inputs/json/priority/union-constructor-clash.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/union-constructor-clash.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/unions.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/unions.json/default/TopLevel.js index 025854b..2b9d888 100644 --- a/base/javascript/test/inputs/json/priority/unions.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/unions.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/url.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/url.json/default/TopLevel.js index cb165e9..41482d3 100644 --- a/base/javascript/test/inputs/json/priority/url.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/url.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/priority/uuids.json/default/TopLevel.js b/head/javascript/test/inputs/json/priority/uuids.json/default/TopLevel.js index 9131b1f..dbd1453 100644 --- a/base/javascript/test/inputs/json/priority/uuids.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/priority/uuids.json/default/TopLevel.js @@ -130,7 +130,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (typeof typ === "object") { return typ.hasOwnProperty("uuid") ? typeof val === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(val) ? val : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/samples/bitcoin-block.json/default/TopLevel.js b/head/javascript/test/inputs/json/samples/bitcoin-block.json/default/TopLevel.js index 6cf685b..fb5d5ee 100644 --- a/base/javascript/test/inputs/json/samples/bitcoin-block.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/samples/bitcoin-block.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/samples/copy-with-property.json/default/TopLevel.js b/head/javascript/test/inputs/json/samples/copy-with-property.json/default/TopLevel.js index 2ed8b2d..b2d0da1 100644 --- a/base/javascript/test/inputs/json/samples/copy-with-property.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/samples/copy-with-property.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/samples/getting-started.json/default/TopLevel.js b/head/javascript/test/inputs/json/samples/getting-started.json/default/TopLevel.js index e860f8d..293caf7 100644 --- a/base/javascript/test/inputs/json/samples/getting-started.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/samples/getting-started.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/samples/github-events.json/default/TopLevel.js b/head/javascript/test/inputs/json/samples/github-events.json/default/TopLevel.js index 7344cc2..d2bd14b 100644 --- a/base/javascript/test/inputs/json/samples/github-events.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/samples/github-events.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/samples/kitchen-sink.json/default/TopLevel.js b/head/javascript/test/inputs/json/samples/kitchen-sink.json/default/TopLevel.js index 4b0251d..fe3a002 100644 --- a/base/javascript/test/inputs/json/samples/kitchen-sink.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/samples/kitchen-sink.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/samples/null-safe.json/default/TopLevel.js b/head/javascript/test/inputs/json/samples/null-safe.json/default/TopLevel.js index b3e2d3f..83064a1 100644 --- a/base/javascript/test/inputs/json/samples/null-safe.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/samples/null-safe.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/samples/pokedex.json/default/TopLevel.js b/head/javascript/test/inputs/json/samples/pokedex.json/default/TopLevel.js index 8f21bd6..3d13ee8 100644 --- a/base/javascript/test/inputs/json/samples/pokedex.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/samples/pokedex.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/samples/reddit.json/default/TopLevel.js b/head/javascript/test/inputs/json/samples/reddit.json/default/TopLevel.js index a44c8fb..e07d07d 100644 --- a/base/javascript/test/inputs/json/samples/reddit.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/samples/reddit.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/samples/simple-object.json/default/TopLevel.js b/head/javascript/test/inputs/json/samples/simple-object.json/default/TopLevel.js index 9d5ed50..f7aac63 100644 --- a/base/javascript/test/inputs/json/samples/simple-object.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/samples/simple-object.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/samples/spotify-album.json/default/TopLevel.js b/head/javascript/test/inputs/json/samples/spotify-album.json/default/TopLevel.js index c47efb8..21a4eaf 100644 --- a/base/javascript/test/inputs/json/samples/spotify-album.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/samples/spotify-album.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/samples/us-avg-temperatures.json/default/TopLevel.js b/head/javascript/test/inputs/json/samples/us-avg-temperatures.json/default/TopLevel.js index 279fd7c..2843bb9 100644 --- a/base/javascript/test/inputs/json/samples/us-avg-temperatures.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/samples/us-avg-temperatures.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/javascript/test/inputs/json/samples/us-senators.json/default/TopLevel.js b/head/javascript/test/inputs/json/samples/us-senators.json/default/TopLevel.js index 0b8f089..3852fa9 100644 --- a/base/javascript/test/inputs/json/samples/us-senators.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/samples/us-senators.json/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/head/schema-dart/test/inputs/regressions/unicode-codepoint-length.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/regressions/unicode-codepoint-length.schema/default/TopLevel.dart new file mode 100644 index 0000000..8e891ab --- /dev/null +++ b/head/schema-dart/test/inputs/regressions/unicode-codepoint-length.schema/default/TopLevel.dart @@ -0,0 +1,33 @@ +// 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 String exact; + final String maximum; + final String minimum; + + TopLevel({ + required this.exact, + required this.maximum, + required this.minimum, + }); + + factory TopLevel.fromJson(Map json) => TopLevel( + exact: ((x) => RegExp("^[^!]+\u0024").hasMatch(x) ? x : throw FormatException("Expected matching string"))(((x) => x.runes.length >= 2 && x.runes.length <= 2 ? x : throw FormatException("Expected bounded string"))(json["exact"])), + maximum: ((x) => true && x.runes.length <= 1 ? x : throw FormatException("Expected bounded string"))(json["maximum"]), + minimum: ((x) => x.runes.length >= 2 && true ? x : throw FormatException("Expected bounded string"))(json["minimum"]), + ); + + Map toJson() => { + "exact": exact, + "maximum": maximum, + "minimum": minimum, + }; +} diff --git a/base/schema-dart/test/inputs/schema/minmaxlength.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/minmaxlength.schema/default/TopLevel.dart index f1634f2..aaf220c 100644 --- a/base/schema-dart/test/inputs/schema/minmaxlength.schema/default/TopLevel.dart +++ b/head/schema-dart/test/inputs/schema/minmaxlength.schema/default/TopLevel.dart @@ -30,14 +30,14 @@ class TopLevel { }); factory TopLevel.fromJson(Map json) => TopLevel( - intersection: ((x) => x.length >= 4 && x.length <= 5 ? x : throw FormatException("Expected bounded string"))(json["intersection"]), + intersection: ((x) => x.runes.length >= 4 && x.runes.length <= 5 ? x : throw FormatException("Expected bounded string"))(json["intersection"]), inUnion: json["inUnion"], - maxlength: ((x) => true && x.length <= 5 ? x : throw FormatException("Expected bounded string"))(json["maxlength"]), - minlength: ((x) => x.length >= 3 && true ? x : throw FormatException("Expected bounded string"))(json["minlength"]), - minMaxIntersection: ((x) => x.length >= 3 && x.length <= 5 ? x : throw FormatException("Expected bounded string"))(json["minMaxIntersection"]), - minmaxlength: ((x) => x.length >= 3 && x.length <= 5 ? x : throw FormatException("Expected bounded string"))(json["minmaxlength"]), + maxlength: ((x) => true && x.runes.length <= 5 ? x : throw FormatException("Expected bounded string"))(json["maxlength"]), + minlength: ((x) => x.runes.length >= 3 && true ? x : throw FormatException("Expected bounded string"))(json["minlength"]), + minMaxIntersection: ((x) => x.runes.length >= 3 && x.runes.length <= 5 ? x : throw FormatException("Expected bounded string"))(json["minMaxIntersection"]), + minmaxlength: ((x) => x.runes.length >= 3 && x.runes.length <= 5 ? x : throw FormatException("Expected bounded string"))(json["minmaxlength"]), minMaxUnion: json["minMaxUnion"], - union: ((x) => x.length >= 3 && x.length <= 6 ? x : throw FormatException("Expected bounded string"))(json["union"]), + union: ((x) => x.runes.length >= 3 && x.runes.length <= 6 ? x : throw FormatException("Expected bounded string"))(json["union"]), ); Map toJson() => { diff --git a/base/schema-dart/test/inputs/schema/optional-const-ref.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/optional-const-ref.schema/default/TopLevel.dart index 47f7b1d..ca79572 100644 --- a/base/schema-dart/test/inputs/schema/optional-const-ref.schema/default/TopLevel.dart +++ b/head/schema-dart/test/inputs/schema/optional-const-ref.schema/default/TopLevel.dart @@ -30,10 +30,10 @@ class TopLevel { factory TopLevel.fromJson(Map json) => TopLevel( coordinates: json["coordinates"] == null ? null : List.from(json["coordinates"]!.map((x) => Coordinate.fromJson(x))), count: json["count"] == null ? null : ((x) => x >= 1 && x <= 100 ? x : throw FormatException("Expected bounded number"))(json["count"]), - label: json["label"] == null ? null : ((x) => x.length >= 2 && x.length <= 16 ? x : throw FormatException("Expected bounded string"))(json["label"]), + label: json["label"] == null ? null : ((x) => x.runes.length >= 2 && x.runes.length <= 16 ? x : throw FormatException("Expected bounded string"))(json["label"]), requiredCoordinates: List.from(json["requiredCoordinates"].map((x) => Coordinate.fromJson(x))), requiredCount: ((x) => x >= 1 && x <= 100 ? x : throw FormatException("Expected bounded number"))(json["requiredCount"]), - requiredLabel: ((x) => x.length >= 2 && x.length <= 16 ? x : throw FormatException("Expected bounded string"))(json["requiredLabel"]), + requiredLabel: ((x) => x.runes.length >= 2 && x.runes.length <= 16 ? x : throw FormatException("Expected bounded string"))(json["requiredLabel"]), weight: json["weight"]?.toDouble() == null ? null : ((x) => x >= 0.5 && x <= 99.5 ? x : throw FormatException("Expected bounded number"))(json["weight"]?.toDouble()), ); diff --git a/base/schema-dart/test/inputs/schema/optional-constraints.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/optional-constraints.schema/default/TopLevel.dart index 3163740..1111bcb 100644 --- a/base/schema-dart/test/inputs/schema/optional-constraints.schema/default/TopLevel.dart +++ b/head/schema-dart/test/inputs/schema/optional-constraints.schema/default/TopLevel.dart @@ -27,7 +27,7 @@ class TopLevel { optDouble: json["optDouble"]?.toDouble() == null ? null : ((x) => x >= 0.5 && x <= 99.5 ? x : throw FormatException("Expected bounded number"))(json["optDouble"]?.toDouble()), optInt: json["optInt"] == null ? null : ((x) => x >= 0 && x <= 100 ? x : throw FormatException("Expected bounded number"))(json["optInt"]), optPattern: json["optPattern"] == null ? null : ((x) => RegExp("^[a-z]+\u0024").hasMatch(x) ? x : throw FormatException("Expected matching string"))(json["optPattern"]), - optString: json["optString"] == null ? null : ((x) => x.length >= 3 && x.length <= 10 ? x : throw FormatException("Expected bounded string"))(json["optString"]), + optString: json["optString"] == null ? null : ((x) => x.runes.length >= 3 && x.runes.length <= 10 ? x : throw FormatException("Expected bounded string"))(json["optString"]), reqZeroMin: ((x) => x >= 0 && x <= 100 ? x : throw FormatException("Expected bounded number"))(json["reqZeroMin"]), ); diff --git a/base/schema-dart/test/inputs/schema/renaming-bug.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/renaming-bug.schema/default/TopLevel.dart index 08e123e..660c8ca 100644 --- a/base/schema-dart/test/inputs/schema/renaming-bug.schema/default/TopLevel.dart +++ b/head/schema-dart/test/inputs/schema/renaming-bug.schema/default/TopLevel.dart @@ -69,7 +69,7 @@ class Berry { factory Berry.fromJson(Map json) => Berry( color: json["color"] == null ? null : Color.fromJson(json["color"]), - name: json["name"] == null ? null : ((x) => x.length >= 1 && true ? x : throw FormatException("Expected bounded string"))(json["name"]), + name: json["name"] == null ? null : ((x) => x.runes.length >= 1 && true ? x : throw FormatException("Expected bounded string"))(json["name"]), shapes: json["shapes"] == null ? null : List.from(json["shapes"]!.map((x) => Shape.fromJson(x))), ); @@ -227,7 +227,7 @@ class Vehicle { factory Vehicle.fromJson(Map json) => Vehicle( brand: json["brand"], - id: json["id"] == null ? null : ((x) => x.length >= 1 && true ? x : throw FormatException("Expected bounded string"))(json["id"]), + id: json["id"] == null ? null : ((x) => x.runes.length >= 1 && true ? x : throw FormatException("Expected bounded string"))(json["id"]), speed: json["speed"] == null ? null : Speed.fromJson(json["speed"]), subModule: json["subModule"], type: json["type"] == null ? null : VehicleType.fromJson(json["type"]), diff --git a/base/schema-dart/test/inputs/schema/schema-constraints.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/schema-constraints.schema/default/TopLevel.dart index 01d92d0..3efdf2e 100644 --- a/base/schema-dart/test/inputs/schema/schema-constraints.schema/default/TopLevel.dart +++ b/head/schema-dart/test/inputs/schema/schema-constraints.schema/default/TopLevel.dart @@ -18,7 +18,7 @@ class TopLevel { }); factory TopLevel.fromJson(Map json) => TopLevel( - minMaxLength: ((x) => x.length >= 5 && x.length <= 5 ? x : throw FormatException("Expected bounded string"))(json["minMaxLength"]), + minMaxLength: ((x) => x.runes.length >= 5 && x.runes.length <= 5 ? x : throw FormatException("Expected bounded string"))(json["minMaxLength"]), percent: ((x) => x >= 0 && x <= 1 ? x : throw FormatException("Expected bounded number"))(json["percent"]?.toDouble()), ); diff --git a/base/schema-flow/test/inputs/schema/accessors.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/accessors.schema/default/TopLevel.js index 84b5ac7..eb6ec52 100644 --- a/base/schema-flow/test/inputs/schema/accessors.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/accessors.schema/default/TopLevel.js @@ -145,7 +145,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/all-of-additional-properties-false.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/all-of-additional-properties-false.schema/default/TopLevel.js index 71263b3..f396e99 100644 --- a/base/schema-flow/test/inputs/schema/all-of-additional-properties-false.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/all-of-additional-properties-false.schema/default/TopLevel.js @@ -147,7 +147,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/any.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/any.schema/default/TopLevel.js index 6b5c82c..a815d1f 100644 --- a/base/schema-flow/test/inputs/schema/any.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/any.schema/default/TopLevel.js @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/bool-string.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/bool-string.schema/default/TopLevel.js index cbc22b4..b091ee6 100644 --- a/base/schema-flow/test/inputs/schema/bool-string.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/bool-string.schema/default/TopLevel.js @@ -144,7 +144,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/boolean-subschema.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/boolean-subschema.schema/default/TopLevel.js index c5b572c..89ed849 100644 --- a/base/schema-flow/test/inputs/schema/boolean-subschema.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/boolean-subschema.schema/default/TopLevel.js @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/camelCase.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/camelCase.schema/default/TopLevel.js index 36b2fbe..68c5bb7 100644 --- a/base/schema-flow/test/inputs/schema/camelCase.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/camelCase.schema/default/TopLevel.js @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/class-map-union.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/class-map-union.schema/default/TopLevel.js index 63ad264..bd843f1 100644 --- a/base/schema-flow/test/inputs/schema/class-map-union.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/class-map-union.schema/default/TopLevel.js @@ -152,7 +152,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/class-with-additional.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/class-with-additional.schema/default/TopLevel.js index 790d6ae..ac8ad1e 100644 --- a/base/schema-flow/test/inputs/schema/class-with-additional.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/class-with-additional.schema/default/TopLevel.js @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.js index 5801994..f43328c 100644 --- a/base/schema-flow/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.js @@ -150,7 +150,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.js index 64ff7f3..f51219c 100644 --- a/base/schema-flow/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.js @@ -156,7 +156,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/comment-injection-nested-comment.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/comment-injection-nested-comment.schema/default/TopLevel.js index 39f4b8f..7347c36 100644 --- a/base/schema-flow/test/inputs/schema/comment-injection-nested-comment.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/comment-injection-nested-comment.schema/default/TopLevel.js @@ -147,7 +147,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/comment-injection.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/comment-injection.schema/default/TopLevel.js index 1a6126f..c113d8f 100644 --- a/base/schema-flow/test/inputs/schema/comment-injection.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/comment-injection.schema/default/TopLevel.js @@ -175,7 +175,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/const-non-string.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/const-non-string.schema/default/TopLevel.js index 8a6b3a5..a2be7c1 100644 --- a/base/schema-flow/test/inputs/schema/const-non-string.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/const-non-string.schema/default/TopLevel.js @@ -143,7 +143,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/constructor.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/constructor.schema/default/TopLevel.js index 374bfba..8d064b4 100644 --- a/base/schema-flow/test/inputs/schema/constructor.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/constructor.schema/default/TopLevel.js @@ -141,7 +141,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/cut-enum.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/cut-enum.schema/default/TopLevel.js index ca769c1..5fc62ff 100644 --- a/base/schema-flow/test/inputs/schema/cut-enum.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/cut-enum.schema/default/TopLevel.js @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/date-time-or-string.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/date-time-or-string.schema/default/TopLevel.js index cceb6d3..a07fc3e 100644 --- a/base/schema-flow/test/inputs/schema/date-time-or-string.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/date-time-or-string.schema/default/TopLevel.js @@ -142,7 +142,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/date-time.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/date-time.schema/default/TopLevel.js index 1ab4b73..7217235 100644 --- a/base/schema-flow/test/inputs/schema/date-time.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/date-time.schema/default/TopLevel.js @@ -145,7 +145,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/default-value.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/default-value.schema/default/TopLevel.js index 3b87590..9357b41 100644 --- a/base/schema-flow/test/inputs/schema/default-value.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/default-value.schema/default/TopLevel.js @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/description-with-double-quotes.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/description-with-double-quotes.schema/default/TopLevel.js index 9e9aa40..5a53374 100644 --- a/base/schema-flow/test/inputs/schema/description-with-double-quotes.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/description-with-double-quotes.schema/default/TopLevel.js @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/description.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/description.schema/default/TopLevel.js index e48ae9c..477f6b6 100644 --- a/base/schema-flow/test/inputs/schema/description.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/description.schema/default/TopLevel.js @@ -174,7 +174,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/direct-union.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/direct-union.schema/default/TopLevel.js index c5f14fa..7c502bb 100644 --- a/base/schema-flow/test/inputs/schema/direct-union.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/direct-union.schema/default/TopLevel.js @@ -142,7 +142,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/empty-object.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/empty-object.schema/default/TopLevel.js index b73bc0c..6301e5d 100644 --- a/base/schema-flow/test/inputs/schema/empty-object.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/empty-object.schema/default/TopLevel.js @@ -133,7 +133,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/enum-large.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/enum-large.schema/default/TopLevel.js index 751e484..5c60925 100644 --- a/base/schema-flow/test/inputs/schema/enum-large.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/enum-large.schema/default/TopLevel.js @@ -164,7 +164,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/enum-with-null.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/enum-with-null.schema/default/TopLevel.js index 6207039..4d0f60f 100644 --- a/base/schema-flow/test/inputs/schema/enum-with-null.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/enum-with-null.schema/default/TopLevel.js @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/enum-with-values.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/enum-with-values.schema/default/TopLevel.js index 4bd336a..65eb190 100644 --- a/base/schema-flow/test/inputs/schema/enum-with-values.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/enum-with-values.schema/default/TopLevel.js @@ -145,7 +145,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/enum.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/enum.schema/default/TopLevel.js index 684fee0..16b6fcf 100644 --- a/base/schema-flow/test/inputs/schema/enum.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/enum.schema/default/TopLevel.js @@ -157,7 +157,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/fractional-bounds.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/fractional-bounds.schema/default/TopLevel.js index 14c613b..05dba1b 100644 --- a/base/schema-flow/test/inputs/schema/fractional-bounds.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/fractional-bounds.schema/default/TopLevel.js @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/go-schema-pattern-properties.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/go-schema-pattern-properties.schema/default/TopLevel.js index 59da3cf..db60ec3 100644 --- a/base/schema-flow/test/inputs/schema/go-schema-pattern-properties.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/go-schema-pattern-properties.schema/default/TopLevel.js @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/haskell-enum-forbidden.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/haskell-enum-forbidden.schema/default/TopLevel.js index d7eea60..87b604a 100644 --- a/base/schema-flow/test/inputs/schema/haskell-enum-forbidden.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/haskell-enum-forbidden.schema/default/TopLevel.js @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/id-no-address.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/id-no-address.schema/default/TopLevel.js index c974875..cd40fc2 100644 --- a/base/schema-flow/test/inputs/schema/id-no-address.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/id-no-address.schema/default/TopLevel.js @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/id-root.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/id-root.schema/default/TopLevel.js index 713bc4e..d9cba86 100644 --- a/base/schema-flow/test/inputs/schema/id-root.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/id-root.schema/default/TopLevel.js @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/ie-suffix-singularization.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/ie-suffix-singularization.schema/default/TopLevel.js index ab20ba6..e1474d0 100644 --- a/base/schema-flow/test/inputs/schema/ie-suffix-singularization.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/ie-suffix-singularization.schema/default/TopLevel.js @@ -142,7 +142,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/implicit-all-of.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/implicit-all-of.schema/default/TopLevel.js index c39cbdd..f5eefd3 100644 --- a/base/schema-flow/test/inputs/schema/implicit-all-of.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/implicit-all-of.schema/default/TopLevel.js @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/implicit-class-array-union.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/implicit-class-array-union.schema/default/TopLevel.js index a6ffd3a..4c7e0f0 100644 --- a/base/schema-flow/test/inputs/schema/implicit-class-array-union.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/implicit-class-array-union.schema/default/TopLevel.js @@ -143,7 +143,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/implicit-one-of.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/implicit-one-of.schema/default/TopLevel.js index 9682fb2..f49d653 100644 --- a/base/schema-flow/test/inputs/schema/implicit-one-of.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/implicit-one-of.schema/default/TopLevel.js @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/integer-before-number.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/integer-before-number.schema/default/TopLevel.js index 9190489..b0b74b2 100644 --- a/base/schema-flow/test/inputs/schema/integer-before-number.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/integer-before-number.schema/default/TopLevel.js @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/integer-float-union.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/integer-float-union.schema/default/TopLevel.js index b472728..3e09a4a 100644 --- a/base/schema-flow/test/inputs/schema/integer-float-union.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/integer-float-union.schema/default/TopLevel.js @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/integer-string.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/integer-string.schema/default/TopLevel.js index 4926aaf..5a379d8 100644 --- a/base/schema-flow/test/inputs/schema/integer-string.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/integer-string.schema/default/TopLevel.js @@ -144,7 +144,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/integer-type.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/integer-type.schema/default/TopLevel.js index 4fd4f78..124a5d6 100644 --- a/base/schema-flow/test/inputs/schema/integer-type.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/integer-type.schema/default/TopLevel.js @@ -144,7 +144,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/intersection-nested.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/intersection-nested.schema/default/TopLevel.js index ec13bd5..1f6d2ea 100644 --- a/base/schema-flow/test/inputs/schema/intersection-nested.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/intersection-nested.schema/default/TopLevel.js @@ -135,7 +135,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/intersection.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/intersection.schema/default/TopLevel.js index eb28f59..6f84dc8 100644 --- a/base/schema-flow/test/inputs/schema/intersection.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/intersection.schema/default/TopLevel.js @@ -141,7 +141,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/issue2680-top-level-array.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/issue2680-top-level-array.schema/default/TopLevel.js index dcbd39d..9a2c339 100644 --- a/base/schema-flow/test/inputs/schema/issue2680-top-level-array.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/issue2680-top-level-array.schema/default/TopLevel.js @@ -133,7 +133,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/keyword-enum.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/keyword-enum.schema/default/TopLevel.js index b853cb3..c207e9f 100644 --- a/base/schema-flow/test/inputs/schema/keyword-enum.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/keyword-enum.schema/default/TopLevel.js @@ -415,7 +415,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/keyword-unions.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/keyword-unions.schema/default/TopLevel.js index e729b45..e440d18 100644 --- a/base/schema-flow/test/inputs/schema/keyword-unions.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/keyword-unions.schema/default/TopLevel.js @@ -1792,7 +1792,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/light.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/light.schema/default/TopLevel.js index 595fe3b..d4bd0a4 100644 --- a/base/schema-flow/test/inputs/schema/light.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/light.schema/default/TopLevel.js @@ -141,7 +141,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/list.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/list.schema/default/TopLevel.js index 25a9304..4dc419c 100644 --- a/base/schema-flow/test/inputs/schema/list.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/list.schema/default/TopLevel.js @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/min-max-items.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/min-max-items.schema/default/TopLevel.js index 4e5fae6..6853c06 100644 --- a/base/schema-flow/test/inputs/schema/min-max-items.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/min-max-items.schema/default/TopLevel.js @@ -142,7 +142,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/minmax-integer.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/minmax-integer.schema/default/TopLevel.js index 24d004c..7f1b193 100644 --- a/base/schema-flow/test/inputs/schema/minmax-integer.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/minmax-integer.schema/default/TopLevel.js @@ -143,7 +143,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/minmax.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/minmax.schema/default/TopLevel.js index cb357ab..b9db934 100644 --- a/base/schema-flow/test/inputs/schema/minmax.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/minmax.schema/default/TopLevel.js @@ -143,7 +143,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/minmaxlength.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/minmaxlength.schema/default/TopLevel.js index 47461fb..2c105dc 100644 --- a/base/schema-flow/test/inputs/schema/minmaxlength.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/minmaxlength.schema/default/TopLevel.js @@ -145,7 +145,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/multi-type-enum.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/multi-type-enum.schema/default/TopLevel.js index 1650cb5..ed8de71 100644 --- a/base/schema-flow/test/inputs/schema/multi-type-enum.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/multi-type-enum.schema/default/TopLevel.js @@ -143,7 +143,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/mutually-recursive.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/mutually-recursive.schema/default/TopLevel.js index 4adc3aa..ec6f3b6 100644 --- a/base/schema-flow/test/inputs/schema/mutually-recursive.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/mutually-recursive.schema/default/TopLevel.js @@ -143,7 +143,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/nested-intersection-union.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/nested-intersection-union.schema/default/TopLevel.js index 30b98a7..acf4266 100644 --- a/base/schema-flow/test/inputs/schema/nested-intersection-union.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/nested-intersection-union.schema/default/TopLevel.js @@ -143,7 +143,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/non-standard-ref.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/non-standard-ref.schema/default/TopLevel.js index 4418b17..a7e0805 100644 --- a/base/schema-flow/test/inputs/schema/non-standard-ref.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/non-standard-ref.schema/default/TopLevel.js @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/nullable-optional-one-of.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/nullable-optional-one-of.schema/default/TopLevel.js index 41cfef5..6bcb6b6 100644 --- a/base/schema-flow/test/inputs/schema/nullable-optional-one-of.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/nullable-optional-one-of.schema/default/TopLevel.js @@ -141,7 +141,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/object-type-required.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/object-type-required.schema/default/TopLevel.js index 84180ae..d201ab6 100644 --- a/base/schema-flow/test/inputs/schema/object-type-required.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/object-type-required.schema/default/TopLevel.js @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/optional-any.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/optional-any.schema/default/TopLevel.js index e253b10..a00eb46 100644 --- a/base/schema-flow/test/inputs/schema/optional-any.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/optional-any.schema/default/TopLevel.js @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/optional-const-ref.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/optional-const-ref.schema/default/TopLevel.js index 63da65e..82516b7 100644 --- a/base/schema-flow/test/inputs/schema/optional-const-ref.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/optional-const-ref.schema/default/TopLevel.js @@ -146,7 +146,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/optional-constraints.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/optional-constraints.schema/default/TopLevel.js index 74a9b1d..b842458 100644 --- a/base/schema-flow/test/inputs/schema/optional-constraints.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/optional-constraints.schema/default/TopLevel.js @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/optional-date-time.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/optional-date-time.schema/default/TopLevel.js index abd5fa5..6768c4f 100644 --- a/base/schema-flow/test/inputs/schema/optional-date-time.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/optional-date-time.schema/default/TopLevel.js @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/optional-enum.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/optional-enum.schema/default/TopLevel.js index 3f9a7de..6801fec 100644 --- a/base/schema-flow/test/inputs/schema/optional-enum.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/optional-enum.schema/default/TopLevel.js @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/pattern.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/pattern.schema/default/TopLevel.js index be048e5..6d97539 100644 --- a/base/schema-flow/test/inputs/schema/pattern.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/pattern.schema/default/TopLevel.js @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/postman-collection.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/postman-collection.schema/default/TopLevel.js index 6f9782c..fccf8dc 100644 --- a/base/schema-flow/test/inputs/schema/postman-collection.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/postman-collection.schema/default/TopLevel.js @@ -146,7 +146,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/prefix-items.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/prefix-items.schema/default/TopLevel.js index 38b8ba6..e95f56b 100644 --- a/base/schema-flow/test/inputs/schema/prefix-items.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/prefix-items.schema/default/TopLevel.js @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/recursive-union-flattening.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/recursive-union-flattening.schema/default/TopLevel.js index 39251ea..c162621 100644 --- a/base/schema-flow/test/inputs/schema/recursive-union-flattening.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/recursive-union-flattening.schema/default/TopLevel.js @@ -149,7 +149,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/ref-id-files.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/ref-id-files.schema/default/TopLevel.js index ca769c1..5fc62ff 100644 --- a/base/schema-flow/test/inputs/schema/ref-id-files.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/ref-id-files.schema/default/TopLevel.js @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/ref-remote.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/ref-remote.schema/default/TopLevel.js index 25a9304..4dc419c 100644 --- a/base/schema-flow/test/inputs/schema/ref-remote.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/ref-remote.schema/default/TopLevel.js @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/renaming-bug.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/renaming-bug.schema/default/TopLevel.js index 7435250..bade79e 100644 --- a/base/schema-flow/test/inputs/schema/renaming-bug.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/renaming-bug.schema/default/TopLevel.js @@ -238,7 +238,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/required-draft3.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/required-draft3.schema/default/TopLevel.js index 96ddcbf..913f9ee 100644 --- a/base/schema-flow/test/inputs/schema/required-draft3.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/required-draft3.schema/default/TopLevel.js @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/required-non-properties.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/required-non-properties.schema/default/TopLevel.js index ee3c8dd..c43feb9 100644 --- a/base/schema-flow/test/inputs/schema/required-non-properties.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/required-non-properties.schema/default/TopLevel.js @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/required.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/required.schema/default/TopLevel.js index 96ddcbf..913f9ee 100644 --- a/base/schema-flow/test/inputs/schema/required.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/required.schema/default/TopLevel.js @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/rust-cycle-breaker-union.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/rust-cycle-breaker-union.schema/default/TopLevel.js index d7819a5..46a8876 100644 --- a/base/schema-flow/test/inputs/schema/rust-cycle-breaker-union.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/rust-cycle-breaker-union.schema/default/TopLevel.js @@ -145,7 +145,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/schema-constraints.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/schema-constraints.schema/default/TopLevel.js index af326f0..22a906a 100644 --- a/base/schema-flow/test/inputs/schema/schema-constraints.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/schema-constraints.schema/default/TopLevel.js @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/simple-ref.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/simple-ref.schema/default/TopLevel.js index 25a9304..4dc419c 100644 --- a/base/schema-flow/test/inputs/schema/simple-ref.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/simple-ref.schema/default/TopLevel.js @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/strict-optional.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/strict-optional.schema/default/TopLevel.js index 3a28b9f..792e8fe 100644 --- a/base/schema-flow/test/inputs/schema/strict-optional.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/strict-optional.schema/default/TopLevel.js @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/top-level-array.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/top-level-array.schema/default/TopLevel.js index d193cef..f8415a8 100644 --- a/base/schema-flow/test/inputs/schema/top-level-array.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/top-level-array.schema/default/TopLevel.js @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/top-level-enum.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/top-level-enum.schema/default/TopLevel.js index f0c1e9a..d58515e 100644 --- a/base/schema-flow/test/inputs/schema/top-level-enum.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/top-level-enum.schema/default/TopLevel.js @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/top-level-primitive-array.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/top-level-primitive-array.schema/default/TopLevel.js index 16d93a7..c079e36 100644 --- a/base/schema-flow/test/inputs/schema/top-level-primitive-array.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/top-level-primitive-array.schema/default/TopLevel.js @@ -133,7 +133,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/top-level-primitive.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/top-level-primitive.schema/default/TopLevel.js index 2a48909..3a2b495 100644 --- a/base/schema-flow/test/inputs/schema/top-level-primitive.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/top-level-primitive.schema/default/TopLevel.js @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/tuple.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/tuple.schema/default/TopLevel.js index 60f826e..b5722b3 100644 --- a/base/schema-flow/test/inputs/schema/tuple.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/tuple.schema/default/TopLevel.js @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.js index 41b3b6b..2e7b122 100644 --- a/base/schema-flow/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.js @@ -154,7 +154,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/union-int-double.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/union-int-double.schema/default/TopLevel.js index 98beb06..2968d01 100644 --- a/base/schema-flow/test/inputs/schema/union-int-double.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/union-int-double.schema/default/TopLevel.js @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/union-list.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/union-list.schema/default/TopLevel.js index 15dfd79..123512a 100644 --- a/base/schema-flow/test/inputs/schema/union-list.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/union-list.schema/default/TopLevel.js @@ -141,7 +141,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/union.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/union.schema/default/TopLevel.js index 34fccb4..29cc42f 100644 --- a/base/schema-flow/test/inputs/schema/union.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/union.schema/default/TopLevel.js @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/uuid.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/uuid.schema/default/TopLevel.js index 48e0c05..e9f588a 100644 --- a/base/schema-flow/test/inputs/schema/uuid.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/uuid.schema/default/TopLevel.js @@ -147,7 +147,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (typeof typ === "object") { return typ.hasOwnProperty("uuid") ? typeof val === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(val) ? val : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-flow/test/inputs/schema/vega-lite.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/vega-lite.schema/default/TopLevel.js index 133a1ea..ac8d948 100644 --- a/base/schema-flow/test/inputs/schema/vega-lite.schema/default/TopLevel.js +++ b/head/schema-flow/test/inputs/schema/vega-lite.schema/default/TopLevel.js @@ -6227,7 +6227,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/head/schema-javascript/test/inputs/regressions/unicode-codepoint-length.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/regressions/unicode-codepoint-length.schema/default/TopLevel.js new file mode 100644 index 0000000..e0d37ac --- /dev/null +++ b/head/schema-javascript/test/inputs/regressions/unicode-codepoint-length.schema/default/TopLevel.js @@ -0,0 +1,205 @@ +// To parse this data: +// +// const Convert = require("./TopLevel"); +// +// const topLevel = Convert.toTopLevel(json); +// +// These functions will throw an error if the JSON doesn't +// match the expected interface, even if the JSON is valid. + +// Converts JSON strings to/from your types +// and asserts the results of JSON.parse at runtime +function toTopLevel(json) { + return cast(JSON.parse(json), r("TopLevel")); +} + +function topLevelToJson(value) { + return JSON.stringify(uncast(value, r("TopLevel")), null, 2); +} + +function invalidValue(typ, val, key, parent = '') { + const prettyTyp = prettyTypeName(typ); + const parentText = parent ? ` on ${parent}` : ''; + const keyText = key ? ` for key "${key}"` : ''; + throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`); +} + +function prettyTypeName(typ) { + if (Array.isArray(typ)) { + if (typ.length === 2 && typ[0] === undefined) { + return `an optional ${prettyTypeName(typ[1])}`; + } else { + return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`; + } + } else if (typeof typ === "object" && typ.literal !== undefined) { + return typ.literal; + } else { + return typeof typ; + } +} + +function jsonToJSProps(typ) { + if (typ.jsonToJS === undefined) { + const map = {}; + typ.props.forEach((p) => map[p.json] = { key: p.js, typ: p.typ }); + typ.jsonToJS = map; + } + return typ.jsonToJS; +} + +function jsToJSONProps(typ) { + if (typ.jsToJSON === undefined) { + const map = {}; + typ.props.forEach((p) => map[p.js] = { key: p.json, typ: p.typ }); + typ.jsToJSON = map; + } + return typ.jsToJSON; +} + +function transform(val, typ, getProps, key = '', parent = '') { + function transformPrimitive(typ, val) { + if (typeof typ === typeof val) return val; + return invalidValue(typ, val, key, parent); + } + + function transformUnion(typs, val) { + // val must validate against one typ in typs + const l = typs.length; + for (let i = 0; i < l; i++) { + const typ = typs[i]; + try { + return transform(val, typ, getProps); + } catch (_) {} + } + return invalidValue(typs, val, key, parent); + } + + function transformEnum(cases, val) { + if (cases.indexOf(val) !== -1) return val; + return invalidValue(cases.map(a => { return l(a); }), val, key, parent); + } + + function transformArray(typ, val) { + // val must be an array with no invalid elements + if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent); + + return val.map(el => transform(el, typ, getProps)); + } + + function transformDate(val) { + if (val === null) { + return null; + } + const d = new Date(val); + if (isNaN(d.valueOf())) { + return invalidValue(l("Date"), val, key, parent); + } + return d; + } + + function transformObject(props, additional, val) { + if (val === null || typeof val !== "object" || Array.isArray(val)) { + return invalidValue(l(ref || "object"), val, key, parent); + } + const result = {}; + Object.getOwnPropertyNames(props).forEach(key => { + const prop = props[key]; + const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined; + result[prop.key] = transform(v, prop.typ, getProps, key, ref); + }); + Object.getOwnPropertyNames(val).forEach(key => { + if (!Object.prototype.hasOwnProperty.call(props, key)) { + result[key] = transform(val[key], additional, getProps, key, ref); + } + }); + return result; + } + + if (typ === "any") return val; + if (typ === null) { + if (val === null) return val; + return invalidValue(typ, val, key, parent); + } + if (typ === false) return invalidValue(typ, val, key, parent); + let ref = undefined; + while (typeof typ === "object" && typ.ref !== undefined) { + ref = typ.ref; + typ = typeMap[typ.ref]; + } + if (Array.isArray(typ)) return transformEnum(typ, val); + if (typeof typ === "object") { + return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) + : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) + : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val) + : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val) + : invalidValue(typ, val, key, parent); + } + // Numbers can be parsed by Date but shouldn't be. + if (typ === Date && typeof val !== "number") return transformDate(val); + return transformPrimitive(typ, val); +} + +function cast(val, typ) { + return transform(val, typ, jsonToJSProps); +} + +function uncast(val, typ) { + return transform(val, typ, jsToJSONProps); +} + +function l(typ) { + return { literal: typ }; +} + +function a(typ) { + return { arrayItems: typ }; +} + +function i(typ) { + return { integer: typ }; +} + +function p(pattern) { + return { pattern }; +} + +function s(typ, min, max) { + return { string: typ, min, max }; +} + +function n(typ, min, max) { + return { number: typ, min, max }; +} + +function u(...typs) { + return { unionMembers: typs }; +} + +function o(props, additional) { + return { props, additional }; +} + +function m(additional) { + const props = []; + return { props, additional }; +} + +function r(name) { + return { ref: name }; +} + +const typeMap = { + "TopLevel": o([ + { json: "exact", js: "exact", typ: s(p("^[^!]+$"), 2, 2) }, + { json: "maximum", js: "maximum", typ: s("", undefined, 1) }, + { json: "minimum", js: "minimum", typ: s("", 2, undefined) }, + ], "any"), +}; + +module.exports = { + "topLevelToJson": topLevelToJson, + "toTopLevel": toTopLevel, +}; diff --git a/base/schema-javascript/test/inputs/schema/accessors.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/accessors.schema/default/TopLevel.js index 5f15379..0cb914d 100644 --- a/base/schema-javascript/test/inputs/schema/accessors.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/accessors.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/all-of-additional-properties-false.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/all-of-additional-properties-false.schema/default/TopLevel.js index 98c3270..a9cfbf1 100644 --- a/base/schema-javascript/test/inputs/schema/all-of-additional-properties-false.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/all-of-additional-properties-false.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/any.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/any.schema/default/TopLevel.js index 1c59d58..088188b 100644 --- a/base/schema-javascript/test/inputs/schema/any.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/any.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/bool-string.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/bool-string.schema/default/TopLevel.js index 1eddf83..88a930f 100644 --- a/base/schema-javascript/test/inputs/schema/bool-string.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/bool-string.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/boolean-subschema.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/boolean-subschema.schema/default/TopLevel.js index 77cf532..efd36e2 100644 --- a/base/schema-javascript/test/inputs/schema/boolean-subschema.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/boolean-subschema.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/camelCase.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/camelCase.schema/default/TopLevel.js index dc9a9ec..56530f7 100644 --- a/base/schema-javascript/test/inputs/schema/camelCase.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/camelCase.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/class-map-union.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/class-map-union.schema/default/TopLevel.js index d4670ef..c664436 100644 --- a/base/schema-javascript/test/inputs/schema/class-map-union.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/class-map-union.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/class-with-additional.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/class-with-additional.schema/default/TopLevel.js index 16e823d..fa08e02 100644 --- a/base/schema-javascript/test/inputs/schema/class-with-additional.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/class-with-additional.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.js index ee321f8..ff00d85 100644 --- a/base/schema-javascript/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.js index ee321f8..ff00d85 100644 --- a/base/schema-javascript/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/comment-injection-nested-comment.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/comment-injection-nested-comment.schema/default/TopLevel.js index f7915e9..36492fa 100644 --- a/base/schema-javascript/test/inputs/schema/comment-injection-nested-comment.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/comment-injection-nested-comment.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/comment-injection.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/comment-injection.schema/default/TopLevel.js index 17ff1d9..3cccccd 100644 --- a/base/schema-javascript/test/inputs/schema/comment-injection.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/comment-injection.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/const-non-string.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/const-non-string.schema/default/TopLevel.js index 2a58271..caed2d3 100644 --- a/base/schema-javascript/test/inputs/schema/const-non-string.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/const-non-string.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/constructor.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/constructor.schema/default/TopLevel.js index 0e151d3..b1498fc 100644 --- a/base/schema-javascript/test/inputs/schema/constructor.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/constructor.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/cut-enum.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/cut-enum.schema/default/TopLevel.js index 63f88bb..dfb07db 100644 --- a/base/schema-javascript/test/inputs/schema/cut-enum.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/cut-enum.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/date-time-or-string.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/date-time-or-string.schema/default/TopLevel.js index f68579f..740705e 100644 --- a/base/schema-javascript/test/inputs/schema/date-time-or-string.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/date-time-or-string.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/date-time.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/date-time.schema/default/TopLevel.js index 501f05e..ffd542c 100644 --- a/base/schema-javascript/test/inputs/schema/date-time.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/date-time.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/default-value.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/default-value.schema/default/TopLevel.js index 1cfdb88..0573d56 100644 --- a/base/schema-javascript/test/inputs/schema/default-value.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/default-value.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/description-with-double-quotes.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/description-with-double-quotes.schema/default/TopLevel.js index 4ee16bb..fea2e10 100644 --- a/base/schema-javascript/test/inputs/schema/description-with-double-quotes.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/description-with-double-quotes.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/description.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/description.schema/default/TopLevel.js index d415abb..516f737 100644 --- a/base/schema-javascript/test/inputs/schema/description.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/description.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/direct-union.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/direct-union.schema/default/TopLevel.js index 3060e05..1dc2f29 100644 --- a/base/schema-javascript/test/inputs/schema/direct-union.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/direct-union.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/empty-object.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/empty-object.schema/default/TopLevel.js index 535c5dd..8622c1b 100644 --- a/base/schema-javascript/test/inputs/schema/empty-object.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/empty-object.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/enum-large.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/enum-large.schema/default/TopLevel.js index d85c2af..5d86580 100644 --- a/base/schema-javascript/test/inputs/schema/enum-large.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/enum-large.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/enum-with-null.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/enum-with-null.schema/default/TopLevel.js index f2dd301..6e0665a 100644 --- a/base/schema-javascript/test/inputs/schema/enum-with-null.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/enum-with-null.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/enum-with-values.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/enum-with-values.schema/default/TopLevel.js index 9c88c9f..df41b06 100644 --- a/base/schema-javascript/test/inputs/schema/enum-with-values.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/enum-with-values.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/enum.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/enum.schema/default/TopLevel.js index 71bb16c..35015dd 100644 --- a/base/schema-javascript/test/inputs/schema/enum.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/enum.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/fractional-bounds.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/fractional-bounds.schema/default/TopLevel.js index 1bfe2e9..bad58fe 100644 --- a/base/schema-javascript/test/inputs/schema/fractional-bounds.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/fractional-bounds.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/go-schema-pattern-properties.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/go-schema-pattern-properties.schema/default/TopLevel.js index 36cc5e7..adca574 100644 --- a/base/schema-javascript/test/inputs/schema/go-schema-pattern-properties.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/go-schema-pattern-properties.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/haskell-enum-forbidden.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/haskell-enum-forbidden.schema/default/TopLevel.js index d398c9c..7a5e388 100644 --- a/base/schema-javascript/test/inputs/schema/haskell-enum-forbidden.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/haskell-enum-forbidden.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/id-no-address.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/id-no-address.schema/default/TopLevel.js index cbc2a13..8760679 100644 --- a/base/schema-javascript/test/inputs/schema/id-no-address.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/id-no-address.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/id-root.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/id-root.schema/default/TopLevel.js index 35aab9f..9be2181 100644 --- a/base/schema-javascript/test/inputs/schema/id-root.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/id-root.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/ie-suffix-singularization.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/ie-suffix-singularization.schema/default/TopLevel.js index b51b74e..41464ae 100644 --- a/base/schema-javascript/test/inputs/schema/ie-suffix-singularization.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/ie-suffix-singularization.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/implicit-all-of.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/implicit-all-of.schema/default/TopLevel.js index 4bb35ff..7d17b4f 100644 --- a/base/schema-javascript/test/inputs/schema/implicit-all-of.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/implicit-all-of.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/implicit-class-array-union.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/implicit-class-array-union.schema/default/TopLevel.js index d5a1380..f36c0b2 100644 --- a/base/schema-javascript/test/inputs/schema/implicit-class-array-union.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/implicit-class-array-union.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/implicit-one-of.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/implicit-one-of.schema/default/TopLevel.js index 74ecb2f..93ce7c8 100644 --- a/base/schema-javascript/test/inputs/schema/implicit-one-of.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/implicit-one-of.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/integer-before-number.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/integer-before-number.schema/default/TopLevel.js index 6a5aba9..7d79664 100644 --- a/base/schema-javascript/test/inputs/schema/integer-before-number.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/integer-before-number.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/integer-float-union.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/integer-float-union.schema/default/TopLevel.js index cb4c622..cbd7545 100644 --- a/base/schema-javascript/test/inputs/schema/integer-float-union.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/integer-float-union.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/integer-string.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/integer-string.schema/default/TopLevel.js index d6733bc..81bef49 100644 --- a/base/schema-javascript/test/inputs/schema/integer-string.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/integer-string.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/integer-type.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/integer-type.schema/default/TopLevel.js index d67f900..539b102 100644 --- a/base/schema-javascript/test/inputs/schema/integer-type.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/integer-type.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/intersection-nested.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/intersection-nested.schema/default/TopLevel.js index 4eb46cc..870f3aa 100644 --- a/base/schema-javascript/test/inputs/schema/intersection-nested.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/intersection-nested.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/intersection.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/intersection.schema/default/TopLevel.js index 21093b3..8885187 100644 --- a/base/schema-javascript/test/inputs/schema/intersection.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/intersection.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/issue2680-top-level-array.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/issue2680-top-level-array.schema/default/TopLevel.js index bbf1861..ca3c226 100644 --- a/base/schema-javascript/test/inputs/schema/issue2680-top-level-array.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/issue2680-top-level-array.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/keyword-enum.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/keyword-enum.schema/default/TopLevel.js index 5cc3c9f..7100f5a 100644 --- a/base/schema-javascript/test/inputs/schema/keyword-enum.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/keyword-enum.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/keyword-unions.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/keyword-unions.schema/default/TopLevel.js index 9f87186..bbb7038 100644 --- a/base/schema-javascript/test/inputs/schema/keyword-unions.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/keyword-unions.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/light.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/light.schema/default/TopLevel.js index 7ad52b7..650e123 100644 --- a/base/schema-javascript/test/inputs/schema/light.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/light.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/list.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/list.schema/default/TopLevel.js index a7ce0e8..5bc04a2 100644 --- a/base/schema-javascript/test/inputs/schema/list.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/list.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/min-max-items.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/min-max-items.schema/default/TopLevel.js index ff895f8..09dcdab 100644 --- a/base/schema-javascript/test/inputs/schema/min-max-items.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/min-max-items.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/minmax-integer.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/minmax-integer.schema/default/TopLevel.js index 8abc6ff..693b1f1 100644 --- a/base/schema-javascript/test/inputs/schema/minmax-integer.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/minmax-integer.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/minmax.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/minmax.schema/default/TopLevel.js index 7f107cb..3bf2b38 100644 --- a/base/schema-javascript/test/inputs/schema/minmax.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/minmax.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/minmaxlength.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/minmaxlength.schema/default/TopLevel.js index db57f2c..b2ce4c6 100644 --- a/base/schema-javascript/test/inputs/schema/minmaxlength.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/minmaxlength.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/multi-type-enum.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/multi-type-enum.schema/default/TopLevel.js index 2b2b838..aa69a6e 100644 --- a/base/schema-javascript/test/inputs/schema/multi-type-enum.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/multi-type-enum.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/mutually-recursive.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/mutually-recursive.schema/default/TopLevel.js index 6ecb7c2..6e3b399 100644 --- a/base/schema-javascript/test/inputs/schema/mutually-recursive.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/mutually-recursive.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/nested-intersection-union.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/nested-intersection-union.schema/default/TopLevel.js index e9b3997..8a5c403 100644 --- a/base/schema-javascript/test/inputs/schema/nested-intersection-union.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/nested-intersection-union.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/non-standard-ref.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/non-standard-ref.schema/default/TopLevel.js index 2c06c09..d7bfad7 100644 --- a/base/schema-javascript/test/inputs/schema/non-standard-ref.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/non-standard-ref.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/nullable-optional-one-of.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/nullable-optional-one-of.schema/default/TopLevel.js index 3172159..9a164d3 100644 --- a/base/schema-javascript/test/inputs/schema/nullable-optional-one-of.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/nullable-optional-one-of.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/object-type-required.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/object-type-required.schema/default/TopLevel.js index 5fea6e3..66b914a 100644 --- a/base/schema-javascript/test/inputs/schema/object-type-required.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/object-type-required.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/optional-any.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/optional-any.schema/default/TopLevel.js index b9732fd..8b8c8db 100644 --- a/base/schema-javascript/test/inputs/schema/optional-any.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/optional-any.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/optional-const-ref.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/optional-const-ref.schema/default/TopLevel.js index 8f8a942..428a0ed 100644 --- a/base/schema-javascript/test/inputs/schema/optional-const-ref.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/optional-const-ref.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/optional-constraints.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/optional-constraints.schema/default/TopLevel.js index 67b390c..ce5bc95 100644 --- a/base/schema-javascript/test/inputs/schema/optional-constraints.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/optional-constraints.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/optional-date-time.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/optional-date-time.schema/default/TopLevel.js index 94e885b..f69cac9 100644 --- a/base/schema-javascript/test/inputs/schema/optional-date-time.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/optional-date-time.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/optional-enum.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/optional-enum.schema/default/TopLevel.js index 9da47a0..208a938 100644 --- a/base/schema-javascript/test/inputs/schema/optional-enum.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/optional-enum.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/pattern.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/pattern.schema/default/TopLevel.js index 9d8cfb7..54c997d 100644 --- a/base/schema-javascript/test/inputs/schema/pattern.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/pattern.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/postman-collection.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/postman-collection.schema/default/TopLevel.js index eae3943..8d69356 100644 --- a/base/schema-javascript/test/inputs/schema/postman-collection.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/postman-collection.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/prefix-items.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/prefix-items.schema/default/TopLevel.js index 5ce6aaa..b17b3dd 100644 --- a/base/schema-javascript/test/inputs/schema/prefix-items.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/prefix-items.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/recursive-union-flattening.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/recursive-union-flattening.schema/default/TopLevel.js index 99614e6..ae82160 100644 --- a/base/schema-javascript/test/inputs/schema/recursive-union-flattening.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/recursive-union-flattening.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/ref-id-files.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/ref-id-files.schema/default/TopLevel.js index 63f88bb..dfb07db 100644 --- a/base/schema-javascript/test/inputs/schema/ref-id-files.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/ref-id-files.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/ref-remote.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/ref-remote.schema/default/TopLevel.js index a7ce0e8..5bc04a2 100644 --- a/base/schema-javascript/test/inputs/schema/ref-remote.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/ref-remote.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/renaming-bug.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/renaming-bug.schema/default/TopLevel.js index 5bb03ac..c249f53 100644 --- a/base/schema-javascript/test/inputs/schema/renaming-bug.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/renaming-bug.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/required-draft3.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/required-draft3.schema/default/TopLevel.js index a77161c..c56b57d 100644 --- a/base/schema-javascript/test/inputs/schema/required-draft3.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/required-draft3.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/required-non-properties.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/required-non-properties.schema/default/TopLevel.js index e62f270..ed85f72 100644 --- a/base/schema-javascript/test/inputs/schema/required-non-properties.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/required-non-properties.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/required.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/required.schema/default/TopLevel.js index a77161c..c56b57d 100644 --- a/base/schema-javascript/test/inputs/schema/required.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/required.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/rust-cycle-breaker-union.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/rust-cycle-breaker-union.schema/default/TopLevel.js index f8c8b0b..3db51f3 100644 --- a/base/schema-javascript/test/inputs/schema/rust-cycle-breaker-union.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/rust-cycle-breaker-union.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/schema-constraints.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/schema-constraints.schema/default/TopLevel.js index 1866d52..41e9d6f 100644 --- a/base/schema-javascript/test/inputs/schema/schema-constraints.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/schema-constraints.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/simple-ref.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/simple-ref.schema/default/TopLevel.js index a7ce0e8..5bc04a2 100644 --- a/base/schema-javascript/test/inputs/schema/simple-ref.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/simple-ref.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/strict-optional.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/strict-optional.schema/default/TopLevel.js index 9a0dbcd..ada09da 100644 --- a/base/schema-javascript/test/inputs/schema/strict-optional.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/strict-optional.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/top-level-array.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/top-level-array.schema/default/TopLevel.js index 0dd544b..2d9a11d 100644 --- a/base/schema-javascript/test/inputs/schema/top-level-array.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/top-level-array.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/top-level-enum.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/top-level-enum.schema/default/TopLevel.js index f322489..efbe789 100644 --- a/base/schema-javascript/test/inputs/schema/top-level-enum.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/top-level-enum.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/top-level-primitive-array.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/top-level-primitive-array.schema/default/TopLevel.js index 0cb245a..0b34916 100644 --- a/base/schema-javascript/test/inputs/schema/top-level-primitive-array.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/top-level-primitive-array.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/top-level-primitive.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/top-level-primitive.schema/default/TopLevel.js index e86ff20..6723f68 100644 --- a/base/schema-javascript/test/inputs/schema/top-level-primitive.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/top-level-primitive.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/tuple.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/tuple.schema/default/TopLevel.js index f858196..3fc8e90 100644 --- a/base/schema-javascript/test/inputs/schema/tuple.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/tuple.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.js index 43b4f8a..f4f135f 100644 --- a/base/schema-javascript/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/union-int-double.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/union-int-double.schema/default/TopLevel.js index 54a8fdb..500c569 100644 --- a/base/schema-javascript/test/inputs/schema/union-int-double.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/union-int-double.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/union-list.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/union-list.schema/default/TopLevel.js index 627fcaf..9eca1b5 100644 --- a/base/schema-javascript/test/inputs/schema/union-list.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/union-list.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/union.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/union.schema/default/TopLevel.js index 61a950b..e6a3677 100644 --- a/base/schema-javascript/test/inputs/schema/union.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/union.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/uuid.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/uuid.schema/default/TopLevel.js index 8b769d2..f34be5e 100644 --- a/base/schema-javascript/test/inputs/schema/uuid.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/uuid.schema/default/TopLevel.js @@ -130,7 +130,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (typeof typ === "object") { return typ.hasOwnProperty("uuid") ? typeof val === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(val) ? val : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-javascript/test/inputs/schema/vega-lite.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/vega-lite.schema/default/TopLevel.js index 2ab3dc9..5762a17 100644 --- a/base/schema-javascript/test/inputs/schema/vega-lite.schema/default/TopLevel.js +++ b/head/schema-javascript/test/inputs/schema/vega-lite.schema/default/TopLevel.js @@ -129,7 +129,7 @@ function transform(val, typ, getProps, key = '', parent = '') { if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/head/schema-typescript/test/inputs/regressions/unicode-codepoint-length.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/regressions/unicode-codepoint-length.schema/default/TopLevel.ts new file mode 100644 index 0000000..13e9e75 --- /dev/null +++ b/head/schema-typescript/test/inputs/regressions/unicode-codepoint-length.schema/default/TopLevel.ts @@ -0,0 +1,209 @@ +// To parse this data: +// +// import { Convert, TopLevel } from "./TopLevel"; +// +// const topLevel = Convert.toTopLevel(json); +// +// These functions will throw an error if the JSON doesn't +// match the expected interface, even if the JSON is valid. + +export interface TopLevel { + exact: string; + maximum: string; + minimum: string; + [property: string]: unknown | string | string | string; +} + +// Converts JSON strings to/from your types +// and asserts the results of JSON.parse at runtime +export class Convert { + public static toTopLevel(json: string): TopLevel { + return cast(JSON.parse(json), r("TopLevel")); + } + + public static topLevelToJson(value: TopLevel): string { + return JSON.stringify(uncast(value, r("TopLevel")), null, 2); + } +} + +function invalidValue(typ: any, val: any, key: any, parent: any = ''): never { + const prettyTyp = prettyTypeName(typ); + const parentText = parent ? ` on ${parent}` : ''; + const keyText = key ? ` for key "${key}"` : ''; + throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`); +} + +function prettyTypeName(typ: any): string { + if (Array.isArray(typ)) { + if (typ.length === 2 && typ[0] === undefined) { + return `an optional ${prettyTypeName(typ[1])}`; + } else { + return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`; + } + } else if (typeof typ === "object" && typ.literal !== undefined) { + return typ.literal; + } else { + return typeof typ; + } +} + +function jsonToJSProps(typ: any): any { + if (typ.jsonToJS === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ }); + typ.jsonToJS = map; + } + return typ.jsonToJS; +} + +function jsToJSONProps(typ: any): any { + if (typ.jsToJSON === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ }); + typ.jsToJSON = map; + } + return typ.jsToJSON; +} + +function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any { + function transformPrimitive(typ: string, val: any): any { + if (typeof typ === typeof val) return val; + return invalidValue(typ, val, key, parent); + } + + function transformUnion(typs: any[], val: any): any { + // val must validate against one typ in typs + const l = typs.length; + for (let i = 0; i < l; i++) { + const typ = typs[i]; + try { + return transform(val, typ, getProps); + } catch (_) {} + } + return invalidValue(typs, val, key, parent); + } + + function transformEnum(cases: string[], val: any): any { + if (cases.indexOf(val) !== -1) return val; + return invalidValue(cases.map(a => { return l(a); }), val, key, parent); + } + + function transformArray(typ: any, val: any): any { + // val must be an array with no invalid elements + if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent); + + return val.map(el => transform(el, typ, getProps)); + } + + function transformDate(val: any): any { + if (val === null) { + return null; + } + const d = new Date(val); + if (isNaN(d.valueOf())) { + return invalidValue(l("Date"), val, key, parent); + } + return d; + } + + function transformObject(props: { [k: string]: any }, additional: any, val: any): any { + if (val === null || typeof val !== "object" || Array.isArray(val)) { + return invalidValue(l(ref || "object"), val, key, parent); + } + const result: any = {}; + Object.getOwnPropertyNames(props).forEach(key => { + const prop = props[key]; + const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined; + result[prop.key] = transform(v, prop.typ, getProps, key, ref); + }); + Object.getOwnPropertyNames(val).forEach(key => { + if (!Object.prototype.hasOwnProperty.call(props, key)) { + result[key] = transform(val[key], additional, getProps, key, ref); + } + }); + return result; + } + + if (typ === "any") return val; + if (typ === null) { + if (val === null) return val; + return invalidValue(typ, val, key, parent); + } + if (typ === false) return invalidValue(typ, val, key, parent); + let ref: any = undefined; + while (typeof typ === "object" && typ.ref !== undefined) { + ref = typ.ref; + typ = typeMap[typ.ref]; + } + if (Array.isArray(typ)) return transformEnum(typ, val); + if (typeof typ === "object") { + return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) + : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) + : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val) + : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val) + : invalidValue(typ, val, key, parent); + } + // Numbers can be parsed by Date but shouldn't be. + if (typ === Date && typeof val !== "number") return transformDate(val); + return transformPrimitive(typ, val); +} + +function cast(val: any, typ: any): T { + return transform(val, typ, jsonToJSProps); +} + +function uncast(val: T, typ: any): any { + return transform(val, typ, jsToJSONProps); +} + +function l(typ: any) { + return { literal: typ }; +} + +function a(typ: any) { + return { arrayItems: typ }; +} + +function i(typ: any) { + return { integer: typ }; +} + +function p(pattern: any) { + return { pattern }; +} + +function s(typ: any, min: any, max: any) { + return { string: typ, min, max }; +} + +function n(typ: any, min: any, max: any) { + return { number: typ, min, max }; +} + +function u(...typs: any[]) { + return { unionMembers: typs }; +} + +function o(props: any[], additional: any) { + return { props, additional }; +} + +function m(additional: any) { + const props: any[] = []; + return { props, additional }; +} + +function r(name: string) { + return { ref: name }; +} + +const typeMap: any = { + "TopLevel": o([ + { json: "exact", js: "exact", typ: s(p("^[^!]+$"), 2, 2) }, + { json: "maximum", js: "maximum", typ: s("", undefined, 1) }, + { json: "minimum", js: "minimum", typ: s("", 2, undefined) }, + ], "any"), +}; diff --git a/base/schema-typescript/test/inputs/schema/accessors.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/accessors.schema/default/TopLevel.ts index b9fbdf2..b2e4d7e 100644 --- a/base/schema-typescript/test/inputs/schema/accessors.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/accessors.schema/default/TopLevel.ts @@ -142,7 +142,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/all-of-additional-properties-false.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/all-of-additional-properties-false.schema/default/TopLevel.ts index 79fe85b..2d7b0e9 100644 --- a/base/schema-typescript/test/inputs/schema/all-of-additional-properties-false.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/all-of-additional-properties-false.schema/default/TopLevel.ts @@ -142,7 +142,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/any.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/any.schema/default/TopLevel.ts index a33a23b..8e66323 100644 --- a/base/schema-typescript/test/inputs/schema/any.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/any.schema/default/TopLevel.ts @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/bool-string.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/bool-string.schema/default/TopLevel.ts index ebbd8c3..9f8c6c6 100644 --- a/base/schema-typescript/test/inputs/schema/bool-string.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/bool-string.schema/default/TopLevel.ts @@ -144,7 +144,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/boolean-subschema.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/boolean-subschema.schema/default/TopLevel.ts index 6cd2b31..e78dbfc 100644 --- a/base/schema-typescript/test/inputs/schema/boolean-subschema.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/boolean-subschema.schema/default/TopLevel.ts @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/camelCase.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/camelCase.schema/default/TopLevel.ts index 9748b66..617ac26 100644 --- a/base/schema-typescript/test/inputs/schema/camelCase.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/camelCase.schema/default/TopLevel.ts @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/class-map-union.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/class-map-union.schema/default/TopLevel.ts index 8613dec..7dabad5 100644 --- a/base/schema-typescript/test/inputs/schema/class-map-union.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/class-map-union.schema/default/TopLevel.ts @@ -152,7 +152,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/class-with-additional.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/class-with-additional.schema/default/TopLevel.ts index b0f6add..854b6e0 100644 --- a/base/schema-typescript/test/inputs/schema/class-with-additional.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/class-with-additional.schema/default/TopLevel.ts @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.ts index b5db30e..5ea43d9 100644 --- a/base/schema-typescript/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.ts @@ -149,7 +149,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.ts index 2efa565..e3731c5 100644 --- a/base/schema-typescript/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.ts @@ -155,7 +155,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/comment-injection-nested-comment.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/comment-injection-nested-comment.schema/default/TopLevel.ts index f804896..6f0ae2d 100644 --- a/base/schema-typescript/test/inputs/schema/comment-injection-nested-comment.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/comment-injection-nested-comment.schema/default/TopLevel.ts @@ -147,7 +147,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/comment-injection.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/comment-injection.schema/default/TopLevel.ts index 615f083..4a0a168 100644 --- a/base/schema-typescript/test/inputs/schema/comment-injection.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/comment-injection.schema/default/TopLevel.ts @@ -175,7 +175,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/const-non-string.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/const-non-string.schema/default/TopLevel.ts index e537d90..f7a244e 100644 --- a/base/schema-typescript/test/inputs/schema/const-non-string.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/const-non-string.schema/default/TopLevel.ts @@ -142,7 +142,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/constructor.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/constructor.schema/default/TopLevel.ts index 7c378cf..3176ec5 100644 --- a/base/schema-typescript/test/inputs/schema/constructor.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/constructor.schema/default/TopLevel.ts @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/cut-enum.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/cut-enum.schema/default/TopLevel.ts index ee0179f..85812b6 100644 --- a/base/schema-typescript/test/inputs/schema/cut-enum.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/cut-enum.schema/default/TopLevel.ts @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/date-time-or-string.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/date-time-or-string.schema/default/TopLevel.ts index 2cbd5fb..51e77a6 100644 --- a/base/schema-typescript/test/inputs/schema/date-time-or-string.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/date-time-or-string.schema/default/TopLevel.ts @@ -141,7 +141,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/date-time.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/date-time.schema/default/TopLevel.ts index 61f3694..a552ea2 100644 --- a/base/schema-typescript/test/inputs/schema/date-time.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/date-time.schema/default/TopLevel.ts @@ -143,7 +143,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/default-value.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/default-value.schema/default/TopLevel.ts index 6021750..fb7fe69 100644 --- a/base/schema-typescript/test/inputs/schema/default-value.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/default-value.schema/default/TopLevel.ts @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/description-with-double-quotes.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/description-with-double-quotes.schema/default/TopLevel.ts index a4d92a9..3377565 100644 --- a/base/schema-typescript/test/inputs/schema/description-with-double-quotes.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/description-with-double-quotes.schema/default/TopLevel.ts @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/description.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/description.schema/default/TopLevel.ts index ca556a5..44752c4 100644 --- a/base/schema-typescript/test/inputs/schema/description.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/description.schema/default/TopLevel.ts @@ -172,7 +172,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/direct-union.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/direct-union.schema/default/TopLevel.ts index 039777e..0c66b0c 100644 --- a/base/schema-typescript/test/inputs/schema/direct-union.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/direct-union.schema/default/TopLevel.ts @@ -142,7 +142,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/empty-object.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/empty-object.schema/default/TopLevel.ts index ddbc949..82dd04b 100644 --- a/base/schema-typescript/test/inputs/schema/empty-object.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/empty-object.schema/default/TopLevel.ts @@ -133,7 +133,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/enum-large.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/enum-large.schema/default/TopLevel.ts index a2d62de..6904f81 100644 --- a/base/schema-typescript/test/inputs/schema/enum-large.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/enum-large.schema/default/TopLevel.ts @@ -141,7 +141,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/enum-with-null.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/enum-with-null.schema/default/TopLevel.ts index d9a46bb..0740b6c 100644 --- a/base/schema-typescript/test/inputs/schema/enum-with-null.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/enum-with-null.schema/default/TopLevel.ts @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/enum-with-values.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/enum-with-values.schema/default/TopLevel.ts index 87d9ab1..d0201a5 100644 --- a/base/schema-typescript/test/inputs/schema/enum-with-values.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/enum-with-values.schema/default/TopLevel.ts @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/enum.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/enum.schema/default/TopLevel.ts index 2ed0250..27cac86 100644 --- a/base/schema-typescript/test/inputs/schema/enum.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/enum.schema/default/TopLevel.ts @@ -148,7 +148,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/fractional-bounds.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/fractional-bounds.schema/default/TopLevel.ts index ff9f14e..d2c2116 100644 --- a/base/schema-typescript/test/inputs/schema/fractional-bounds.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/fractional-bounds.schema/default/TopLevel.ts @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/go-schema-pattern-properties.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/go-schema-pattern-properties.schema/default/TopLevel.ts index bec548b..00d24c2 100644 --- a/base/schema-typescript/test/inputs/schema/go-schema-pattern-properties.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/go-schema-pattern-properties.schema/default/TopLevel.ts @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/haskell-enum-forbidden.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/haskell-enum-forbidden.schema/default/TopLevel.ts index 05d38cf..aca2dbd 100644 --- a/base/schema-typescript/test/inputs/schema/haskell-enum-forbidden.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/haskell-enum-forbidden.schema/default/TopLevel.ts @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/id-no-address.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/id-no-address.schema/default/TopLevel.ts index 5ba0e25..956e8e2 100644 --- a/base/schema-typescript/test/inputs/schema/id-no-address.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/id-no-address.schema/default/TopLevel.ts @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/id-root.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/id-root.schema/default/TopLevel.ts index 1b6d40d..39449cf 100644 --- a/base/schema-typescript/test/inputs/schema/id-root.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/id-root.schema/default/TopLevel.ts @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/ie-suffix-singularization.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/ie-suffix-singularization.schema/default/TopLevel.ts index 59a5067..a2fcf91 100644 --- a/base/schema-typescript/test/inputs/schema/ie-suffix-singularization.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/ie-suffix-singularization.schema/default/TopLevel.ts @@ -142,7 +142,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/implicit-all-of.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/implicit-all-of.schema/default/TopLevel.ts index a512f81..131b0b6 100644 --- a/base/schema-typescript/test/inputs/schema/implicit-all-of.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/implicit-all-of.schema/default/TopLevel.ts @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/implicit-class-array-union.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/implicit-class-array-union.schema/default/TopLevel.ts index 95d4783..3ed058c 100644 --- a/base/schema-typescript/test/inputs/schema/implicit-class-array-union.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/implicit-class-array-union.schema/default/TopLevel.ts @@ -143,7 +143,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/implicit-one-of.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/implicit-one-of.schema/default/TopLevel.ts index 911edea..3e9a7fa 100644 --- a/base/schema-typescript/test/inputs/schema/implicit-one-of.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/implicit-one-of.schema/default/TopLevel.ts @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/integer-before-number.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/integer-before-number.schema/default/TopLevel.ts index bb63a39..85e189f 100644 --- a/base/schema-typescript/test/inputs/schema/integer-before-number.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/integer-before-number.schema/default/TopLevel.ts @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/integer-float-union.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/integer-float-union.schema/default/TopLevel.ts index e7ae4ea..6215c6d 100644 --- a/base/schema-typescript/test/inputs/schema/integer-float-union.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/integer-float-union.schema/default/TopLevel.ts @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/integer-string.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/integer-string.schema/default/TopLevel.ts index a6901be..5bf5e13 100644 --- a/base/schema-typescript/test/inputs/schema/integer-string.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/integer-string.schema/default/TopLevel.ts @@ -144,7 +144,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/integer-type.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/integer-type.schema/default/TopLevel.ts index c5e5f2b..6d3a2c9 100644 --- a/base/schema-typescript/test/inputs/schema/integer-type.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/integer-type.schema/default/TopLevel.ts @@ -144,7 +144,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/intersection-nested.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/intersection-nested.schema/default/TopLevel.ts index 8191580..634b387 100644 --- a/base/schema-typescript/test/inputs/schema/intersection-nested.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/intersection-nested.schema/default/TopLevel.ts @@ -135,7 +135,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/intersection.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/intersection.schema/default/TopLevel.ts index 91f0663..5eb24bb 100644 --- a/base/schema-typescript/test/inputs/schema/intersection.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/intersection.schema/default/TopLevel.ts @@ -141,7 +141,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/issue2680-top-level-array.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/issue2680-top-level-array.schema/default/TopLevel.ts index 3330b94..d71c1cf 100644 --- a/base/schema-typescript/test/inputs/schema/issue2680-top-level-array.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/issue2680-top-level-array.schema/default/TopLevel.ts @@ -133,7 +133,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/keyword-enum.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/keyword-enum.schema/default/TopLevel.ts index b8d8989..cd15e4e 100644 --- a/base/schema-typescript/test/inputs/schema/keyword-enum.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/keyword-enum.schema/default/TopLevel.ts @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/keyword-unions.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/keyword-unions.schema/default/TopLevel.ts index dc2b7f2..6deada7 100644 --- a/base/schema-typescript/test/inputs/schema/keyword-unions.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/keyword-unions.schema/default/TopLevel.ts @@ -964,7 +964,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/light.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/light.schema/default/TopLevel.ts index 7ac5896..d1ae931 100644 --- a/base/schema-typescript/test/inputs/schema/light.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/light.schema/default/TopLevel.ts @@ -141,7 +141,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/list.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/list.schema/default/TopLevel.ts index 5f1fb8b..dded0d3 100644 --- a/base/schema-typescript/test/inputs/schema/list.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/list.schema/default/TopLevel.ts @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/min-max-items.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/min-max-items.schema/default/TopLevel.ts index b4d074b..7f870ab 100644 --- a/base/schema-typescript/test/inputs/schema/min-max-items.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/min-max-items.schema/default/TopLevel.ts @@ -142,7 +142,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/minmax-integer.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/minmax-integer.schema/default/TopLevel.ts index d489e14..6749711 100644 --- a/base/schema-typescript/test/inputs/schema/minmax-integer.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/minmax-integer.schema/default/TopLevel.ts @@ -143,7 +143,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/minmax.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/minmax.schema/default/TopLevel.ts index 68930d3..7f8a3c5 100644 --- a/base/schema-typescript/test/inputs/schema/minmax.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/minmax.schema/default/TopLevel.ts @@ -143,7 +143,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/minmaxlength.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/minmaxlength.schema/default/TopLevel.ts index d8f10a9..628425c 100644 --- a/base/schema-typescript/test/inputs/schema/minmaxlength.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/minmaxlength.schema/default/TopLevel.ts @@ -145,7 +145,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/multi-type-enum.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/multi-type-enum.schema/default/TopLevel.ts index 4b1816f..3f048f9 100644 --- a/base/schema-typescript/test/inputs/schema/multi-type-enum.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/multi-type-enum.schema/default/TopLevel.ts @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/mutually-recursive.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/mutually-recursive.schema/default/TopLevel.ts index 4f6e40f..1c0453e 100644 --- a/base/schema-typescript/test/inputs/schema/mutually-recursive.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/mutually-recursive.schema/default/TopLevel.ts @@ -143,7 +143,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/nested-intersection-union.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/nested-intersection-union.schema/default/TopLevel.ts index 5ea074f..19d7ac5 100644 --- a/base/schema-typescript/test/inputs/schema/nested-intersection-union.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/nested-intersection-union.schema/default/TopLevel.ts @@ -143,7 +143,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/non-standard-ref.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/non-standard-ref.schema/default/TopLevel.ts index 50c058c..9cd8ae7 100644 --- a/base/schema-typescript/test/inputs/schema/non-standard-ref.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/non-standard-ref.schema/default/TopLevel.ts @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/nullable-optional-one-of.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/nullable-optional-one-of.schema/default/TopLevel.ts index ad71576..4c55d54 100644 --- a/base/schema-typescript/test/inputs/schema/nullable-optional-one-of.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/nullable-optional-one-of.schema/default/TopLevel.ts @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/object-type-required.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/object-type-required.schema/default/TopLevel.ts index 4c5d753..3724284 100644 --- a/base/schema-typescript/test/inputs/schema/object-type-required.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/object-type-required.schema/default/TopLevel.ts @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/optional-any.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/optional-any.schema/default/TopLevel.ts index e88a0c8..5ff5803 100644 --- a/base/schema-typescript/test/inputs/schema/optional-any.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/optional-any.schema/default/TopLevel.ts @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/optional-const-ref.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/optional-const-ref.schema/default/TopLevel.ts index d2f6bc9..8c4941a 100644 --- a/base/schema-typescript/test/inputs/schema/optional-const-ref.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/optional-const-ref.schema/default/TopLevel.ts @@ -146,7 +146,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/optional-constraints.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/optional-constraints.schema/default/TopLevel.ts index d89a506..2c419b8 100644 --- a/base/schema-typescript/test/inputs/schema/optional-constraints.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/optional-constraints.schema/default/TopLevel.ts @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/optional-date-time.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/optional-date-time.schema/default/TopLevel.ts index 7ec824b..976447d 100644 --- a/base/schema-typescript/test/inputs/schema/optional-date-time.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/optional-date-time.schema/default/TopLevel.ts @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/optional-enum.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/optional-enum.schema/default/TopLevel.ts index 4f34cef..fca17e4 100644 --- a/base/schema-typescript/test/inputs/schema/optional-enum.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/optional-enum.schema/default/TopLevel.ts @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/pattern.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/pattern.schema/default/TopLevel.ts index 4c4512e..f1b7115 100644 --- a/base/schema-typescript/test/inputs/schema/pattern.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/pattern.schema/default/TopLevel.ts @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/postman-collection.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/postman-collection.schema/default/TopLevel.ts index 6e85615..7524d1d 100644 --- a/base/schema-typescript/test/inputs/schema/postman-collection.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/postman-collection.schema/default/TopLevel.ts @@ -146,7 +146,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/prefix-items.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/prefix-items.schema/default/TopLevel.ts index 00c935e..96d138a 100644 --- a/base/schema-typescript/test/inputs/schema/prefix-items.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/prefix-items.schema/default/TopLevel.ts @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/recursive-union-flattening.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/recursive-union-flattening.schema/default/TopLevel.ts index 29a676b..3c430b8 100644 --- a/base/schema-typescript/test/inputs/schema/recursive-union-flattening.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/recursive-union-flattening.schema/default/TopLevel.ts @@ -149,7 +149,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/ref-id-files.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/ref-id-files.schema/default/TopLevel.ts index ee0179f..85812b6 100644 --- a/base/schema-typescript/test/inputs/schema/ref-id-files.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/ref-id-files.schema/default/TopLevel.ts @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/ref-remote.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/ref-remote.schema/default/TopLevel.ts index 5f1fb8b..dded0d3 100644 --- a/base/schema-typescript/test/inputs/schema/ref-remote.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/ref-remote.schema/default/TopLevel.ts @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/renaming-bug.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/renaming-bug.schema/default/TopLevel.ts index 1d5fb2f..b5ce6a4 100644 --- a/base/schema-typescript/test/inputs/schema/renaming-bug.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/renaming-bug.schema/default/TopLevel.ts @@ -223,7 +223,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/required-draft3.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/required-draft3.schema/default/TopLevel.ts index c0c5b44..f872b61 100644 --- a/base/schema-typescript/test/inputs/schema/required-draft3.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/required-draft3.schema/default/TopLevel.ts @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/required-non-properties.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/required-non-properties.schema/default/TopLevel.ts index 97f92c2..acfab75 100644 --- a/base/schema-typescript/test/inputs/schema/required-non-properties.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/required-non-properties.schema/default/TopLevel.ts @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/required.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/required.schema/default/TopLevel.ts index c0c5b44..f872b61 100644 --- a/base/schema-typescript/test/inputs/schema/required.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/required.schema/default/TopLevel.ts @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/rust-cycle-breaker-union.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/rust-cycle-breaker-union.schema/default/TopLevel.ts index 47cdf68..e5b6bed 100644 --- a/base/schema-typescript/test/inputs/schema/rust-cycle-breaker-union.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/rust-cycle-breaker-union.schema/default/TopLevel.ts @@ -145,7 +145,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/schema-constraints.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/schema-constraints.schema/default/TopLevel.ts index 47fe187..519be08 100644 --- a/base/schema-typescript/test/inputs/schema/schema-constraints.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/schema-constraints.schema/default/TopLevel.ts @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/simple-ref.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/simple-ref.schema/default/TopLevel.ts index 5f1fb8b..dded0d3 100644 --- a/base/schema-typescript/test/inputs/schema/simple-ref.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/simple-ref.schema/default/TopLevel.ts @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/strict-optional.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/strict-optional.schema/default/TopLevel.ts index 6dd98df..0e871be 100644 --- a/base/schema-typescript/test/inputs/schema/strict-optional.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/strict-optional.schema/default/TopLevel.ts @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/top-level-array.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/top-level-array.schema/default/TopLevel.ts index ad232b8..d01ef11 100644 --- a/base/schema-typescript/test/inputs/schema/top-level-array.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/top-level-array.schema/default/TopLevel.ts @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/top-level-enum.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/top-level-enum.schema/default/TopLevel.ts index 46411b3..0e4a929 100644 --- a/base/schema-typescript/test/inputs/schema/top-level-enum.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/top-level-enum.schema/default/TopLevel.ts @@ -133,7 +133,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/top-level-primitive-array.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/top-level-primitive-array.schema/default/TopLevel.ts index 27a04b8..682ca22 100644 --- a/base/schema-typescript/test/inputs/schema/top-level-primitive-array.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/top-level-primitive-array.schema/default/TopLevel.ts @@ -133,7 +133,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/top-level-primitive.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/top-level-primitive.schema/default/TopLevel.ts index f76aabb..5bbe39c 100644 --- a/base/schema-typescript/test/inputs/schema/top-level-primitive.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/top-level-primitive.schema/default/TopLevel.ts @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/tuple.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/tuple.schema/default/TopLevel.ts index f87fd01..8b57de6 100644 --- a/base/schema-typescript/test/inputs/schema/tuple.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/tuple.schema/default/TopLevel.ts @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.ts index c17365e..208f2bd 100644 --- a/base/schema-typescript/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.ts @@ -151,7 +151,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/union-int-double.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/union-int-double.schema/default/TopLevel.ts index 997f78e..b9e11c7 100644 --- a/base/schema-typescript/test/inputs/schema/union-int-double.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/union-int-double.schema/default/TopLevel.ts @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/union-list.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/union-list.schema/default/TopLevel.ts index 0a104e9..40bf2a3 100644 --- a/base/schema-typescript/test/inputs/schema/union-list.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/union-list.schema/default/TopLevel.ts @@ -141,7 +141,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/union.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/union.schema/default/TopLevel.ts index 05e0ba0..81b4ba7 100644 --- a/base/schema-typescript/test/inputs/schema/union.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/union.schema/default/TopLevel.ts @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/uuid.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/uuid.schema/default/TopLevel.ts index 93183ff..81bc80b 100644 --- a/base/schema-typescript/test/inputs/schema/uuid.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/uuid.schema/default/TopLevel.ts @@ -146,7 +146,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (typeof typ === "object") { return typ.hasOwnProperty("uuid") ? typeof val === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(val) ? val : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/schema-typescript/test/inputs/schema/vega-lite.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/vega-lite.schema/default/TopLevel.ts index 130c5a4..6c560e2 100644 --- a/base/schema-typescript/test/inputs/schema/vega-lite.schema/default/TopLevel.ts +++ b/head/schema-typescript/test/inputs/schema/vega-lite.schema/default/TopLevel.ts @@ -5984,7 +5984,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/head/schema-typescript-effect-schema/test/inputs/regressions/unicode-codepoint-length.schema/default/TopLevel.ts b/head/schema-typescript-effect-schema/test/inputs/regressions/unicode-codepoint-length.schema/default/TopLevel.ts new file mode 100644 index 0000000..9730f77 --- /dev/null +++ b/head/schema-typescript-effect-schema/test/inputs/regressions/unicode-codepoint-length.schema/default/TopLevel.ts @@ -0,0 +1,8 @@ +import * as S from "effect/Schema"; + + +export class TopLevel extends S.Class("TopLevel")({ + "exact": S.String.pipe(S.filter(value => Array.from(value).length >= 2)).pipe(S.filter(value => Array.from(value).length <= 2)).pipe(S.pattern(new RegExp("^[^!]+$"))), + "maximum": S.String.pipe(S.filter(value => Array.from(value).length <= 1)), + "minimum": S.String.pipe(S.filter(value => Array.from(value).length >= 2)), +}) {} diff --git a/base/schema-typescript-effect-schema/test/inputs/schema/minmaxlength.schema/default/TopLevel.ts b/head/schema-typescript-effect-schema/test/inputs/schema/minmaxlength.schema/default/TopLevel.ts index efb94ee..6faae36 100644 --- a/base/schema-typescript-effect-schema/test/inputs/schema/minmaxlength.schema/default/TopLevel.ts +++ b/head/schema-typescript-effect-schema/test/inputs/schema/minmaxlength.schema/default/TopLevel.ts @@ -2,12 +2,12 @@ import * as S from "effect/Schema"; export class TopLevel extends S.Class("TopLevel")({ - "intersection": S.String.pipe(S.minLength(4)).pipe(S.maxLength(5)), - "inUnion": S.Union(S.Number, S.String.pipe(S.minLength(3)).pipe(S.maxLength(5))), - "maxlength": S.String.pipe(S.maxLength(5)), - "minlength": S.String.pipe(S.minLength(3)), - "minMaxIntersection": S.String.pipe(S.minLength(3)).pipe(S.maxLength(5)), - "minmaxlength": S.String.pipe(S.minLength(3)).pipe(S.maxLength(5)), + "intersection": S.String.pipe(S.filter(value => Array.from(value).length >= 4)).pipe(S.filter(value => Array.from(value).length <= 5)), + "inUnion": S.Union(S.Number, S.String.pipe(S.filter(value => Array.from(value).length >= 3)).pipe(S.filter(value => Array.from(value).length <= 5))), + "maxlength": S.String.pipe(S.filter(value => Array.from(value).length <= 5)), + "minlength": S.String.pipe(S.filter(value => Array.from(value).length >= 3)), + "minMaxIntersection": S.String.pipe(S.filter(value => Array.from(value).length >= 3)).pipe(S.filter(value => Array.from(value).length <= 5)), + "minmaxlength": S.String.pipe(S.filter(value => Array.from(value).length >= 3)).pipe(S.filter(value => Array.from(value).length <= 5)), "minMaxUnion": S.String, - "union": S.String.pipe(S.minLength(3)).pipe(S.maxLength(6)), + "union": S.String.pipe(S.filter(value => Array.from(value).length >= 3)).pipe(S.filter(value => Array.from(value).length <= 6)), }) {} diff --git a/base/schema-typescript-effect-schema/test/inputs/schema/optional-const-ref.schema/default/TopLevel.ts b/head/schema-typescript-effect-schema/test/inputs/schema/optional-const-ref.schema/default/TopLevel.ts index f45038e..c8b647c 100644 --- a/base/schema-typescript-effect-schema/test/inputs/schema/optional-const-ref.schema/default/TopLevel.ts +++ b/head/schema-typescript-effect-schema/test/inputs/schema/optional-const-ref.schema/default/TopLevel.ts @@ -9,9 +9,9 @@ export class Coordinate extends S.Class("Coordinate")({ export class TopLevel extends S.Class("TopLevel")({ "coordinates": S.optional(S.NullOr(S.Array(Coordinate))), "count": S.optional(S.NullOr(S.Int.pipe(S.greaterThanOrEqualTo(1)).pipe(S.lessThanOrEqualTo(100)))), - "label": S.optional(S.NullOr(S.String.pipe(S.minLength(2)).pipe(S.maxLength(16)))), + "label": S.optional(S.NullOr(S.String.pipe(S.filter(value => Array.from(value).length >= 2)).pipe(S.filter(value => Array.from(value).length <= 16)))), "requiredCoordinates": S.Array(Coordinate), "requiredCount": S.Int.pipe(S.greaterThanOrEqualTo(1)).pipe(S.lessThanOrEqualTo(100)), - "requiredLabel": S.String.pipe(S.minLength(2)).pipe(S.maxLength(16)), + "requiredLabel": S.String.pipe(S.filter(value => Array.from(value).length >= 2)).pipe(S.filter(value => Array.from(value).length <= 16)), "weight": S.optional(S.NullOr(S.Number.pipe(S.greaterThanOrEqualTo(0.5)).pipe(S.lessThanOrEqualTo(99.5)))), }) {} diff --git a/base/schema-typescript-effect-schema/test/inputs/schema/optional-constraints.schema/default/TopLevel.ts b/head/schema-typescript-effect-schema/test/inputs/schema/optional-constraints.schema/default/TopLevel.ts index 4c5c8ea..725ba7f 100644 --- a/base/schema-typescript-effect-schema/test/inputs/schema/optional-constraints.schema/default/TopLevel.ts +++ b/head/schema-typescript-effect-schema/test/inputs/schema/optional-constraints.schema/default/TopLevel.ts @@ -5,6 +5,6 @@ export class TopLevel extends S.Class("TopLevel")({ "optDouble": S.optional(S.NullOr(S.Number.pipe(S.greaterThanOrEqualTo(0.5)).pipe(S.lessThanOrEqualTo(99.5)))), "optInt": S.optional(S.NullOr(S.Int.pipe(S.greaterThanOrEqualTo(0)).pipe(S.lessThanOrEqualTo(100)))), "optPattern": S.optional(S.NullOr(S.String.pipe(S.pattern(new RegExp("^[a-z]+$"))))), - "optString": S.optional(S.NullOr(S.String.pipe(S.minLength(3)).pipe(S.maxLength(10)))), + "optString": S.optional(S.NullOr(S.String.pipe(S.filter(value => Array.from(value).length >= 3)).pipe(S.filter(value => Array.from(value).length <= 10)))), "reqZeroMin": S.Int.pipe(S.greaterThanOrEqualTo(0)).pipe(S.lessThanOrEqualTo(100)), }) {} diff --git a/base/schema-typescript-effect-schema/test/inputs/schema/renaming-bug.schema/default/TopLevel.ts b/head/schema-typescript-effect-schema/test/inputs/schema/renaming-bug.schema/default/TopLevel.ts index a0c3b07..2437c9f 100644 --- a/base/schema-typescript-effect-schema/test/inputs/schema/renaming-bug.schema/default/TopLevel.ts +++ b/head/schema-typescript-effect-schema/test/inputs/schema/renaming-bug.schema/default/TopLevel.ts @@ -42,7 +42,7 @@ export class Speed extends S.Class("Speed")({ export class Vehicle extends S.Class("Vehicle")({ "brand": S.optional(S.NullOr(S.String)), - "id": S.optional(S.NullOr(S.String.pipe(S.minLength(1)))), + "id": S.optional(S.NullOr(S.String.pipe(S.filter(value => Array.from(value).length >= 1)))), "speed": S.optional(S.NullOr(Speed)), "subModule": S.optional(S.NullOr(S.Boolean)), "type": S.optional(S.NullOr(VehicleType)), @@ -83,7 +83,7 @@ export class Color extends S.Class("Color")({ export class Berry extends S.Class("Berry")({ "color": S.optional(S.NullOr(Color)), - "name": S.optional(S.NullOr(S.String.pipe(S.minLength(1)))), + "name": S.optional(S.NullOr(S.String.pipe(S.filter(value => Array.from(value).length >= 1)))), "shapes": S.optional(S.NullOr(S.Array(Shape))), }) {} diff --git a/base/schema-typescript-effect-schema/test/inputs/schema/schema-constraints.schema/default/TopLevel.ts b/head/schema-typescript-effect-schema/test/inputs/schema/schema-constraints.schema/default/TopLevel.ts index 3e74d87..e9864b8 100644 --- a/base/schema-typescript-effect-schema/test/inputs/schema/schema-constraints.schema/default/TopLevel.ts +++ b/head/schema-typescript-effect-schema/test/inputs/schema/schema-constraints.schema/default/TopLevel.ts @@ -2,6 +2,6 @@ import * as S from "effect/Schema"; export class TopLevel extends S.Class("TopLevel")({ - "minMaxLength": S.String.pipe(S.minLength(5)).pipe(S.maxLength(5)), + "minMaxLength": S.String.pipe(S.filter(value => Array.from(value).length >= 5)).pipe(S.filter(value => Array.from(value).length <= 5)), "percent": S.Number.pipe(S.greaterThanOrEqualTo(0)).pipe(S.lessThanOrEqualTo(1)), }) {} diff --git a/head/schema-typescript-zod/test/inputs/regressions/unicode-codepoint-length.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/regressions/unicode-codepoint-length.schema/default/TopLevel.ts new file mode 100644 index 0000000..927a5f4 --- /dev/null +++ b/head/schema-typescript-zod/test/inputs/regressions/unicode-codepoint-length.schema/default/TopLevel.ts @@ -0,0 +1,9 @@ +import * as z from "zod"; + + +export const TopLevelSchema = z.object({ + "exact": z.string().regex(new RegExp("^[^!]+$")).refine(value => Array.from(value).length >= 2).refine(value => Array.from(value).length <= 2), + "maximum": z.string().refine(value => Array.from(value).length <= 1), + "minimum": z.string().refine(value => Array.from(value).length >= 2), +}); +export type TopLevel = z.infer; diff --git a/base/schema-typescript-zod/test/inputs/schema/minmaxlength.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/minmaxlength.schema/default/TopLevel.ts index 0a16cef..e51d521 100644 --- a/base/schema-typescript-zod/test/inputs/schema/minmaxlength.schema/default/TopLevel.ts +++ b/head/schema-typescript-zod/test/inputs/schema/minmaxlength.schema/default/TopLevel.ts @@ -2,13 +2,13 @@ import * as z from "zod"; export const TopLevelSchema = z.object({ - "intersection": z.string().min(4).max(5), - "inUnion": z.union([z.number(), z.string().min(3).max(5)]), - "maxlength": z.string().max(5), - "minlength": z.string().min(3), - "minMaxIntersection": z.string().min(3).max(5), - "minmaxlength": z.string().min(3).max(5), + "intersection": z.string().refine(value => Array.from(value).length >= 4).refine(value => Array.from(value).length <= 5), + "inUnion": z.union([z.number(), z.string().refine(value => Array.from(value).length >= 3).refine(value => Array.from(value).length <= 5)]), + "maxlength": z.string().refine(value => Array.from(value).length <= 5), + "minlength": z.string().refine(value => Array.from(value).length >= 3), + "minMaxIntersection": z.string().refine(value => Array.from(value).length >= 3).refine(value => Array.from(value).length <= 5), + "minmaxlength": z.string().refine(value => Array.from(value).length >= 3).refine(value => Array.from(value).length <= 5), "minMaxUnion": z.string(), - "union": z.string().min(3).max(6), + "union": z.string().refine(value => Array.from(value).length >= 3).refine(value => Array.from(value).length <= 6), }); export type TopLevel = z.infer; diff --git a/base/schema-typescript-zod/test/inputs/schema/optional-const-ref.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/optional-const-ref.schema/default/TopLevel.ts index 1372ddb..b5b8d6a 100644 --- a/base/schema-typescript-zod/test/inputs/schema/optional-const-ref.schema/default/TopLevel.ts +++ b/head/schema-typescript-zod/test/inputs/schema/optional-const-ref.schema/default/TopLevel.ts @@ -10,10 +10,10 @@ export type Coordinate = z.infer; export const TopLevelSchema = z.object({ "coordinates": z.array(CoordinateSchema).optional(), "count": z.number().int().min(1).max(100).optional(), - "label": z.string().min(2).max(16).optional(), + "label": z.string().refine(value => Array.from(value).length >= 2).refine(value => Array.from(value).length <= 16).optional(), "requiredCoordinates": z.array(CoordinateSchema), "requiredCount": z.number().int().min(1).max(100), - "requiredLabel": z.string().min(2).max(16), + "requiredLabel": z.string().refine(value => Array.from(value).length >= 2).refine(value => Array.from(value).length <= 16), "weight": z.number().min(0.5).max(99.5).optional(), }); export type TopLevel = z.infer; diff --git a/base/schema-typescript-zod/test/inputs/schema/optional-constraints.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/optional-constraints.schema/default/TopLevel.ts index 3c40ff0..40cd92e 100644 --- a/base/schema-typescript-zod/test/inputs/schema/optional-constraints.schema/default/TopLevel.ts +++ b/head/schema-typescript-zod/test/inputs/schema/optional-constraints.schema/default/TopLevel.ts @@ -5,7 +5,7 @@ export const TopLevelSchema = z.object({ "optDouble": z.number().min(0.5).max(99.5).optional(), "optInt": z.number().int().min(0).max(100).optional(), "optPattern": z.string().regex(new RegExp("^[a-z]+$")).optional(), - "optString": z.string().min(3).max(10).optional(), + "optString": z.string().refine(value => Array.from(value).length >= 3).refine(value => Array.from(value).length <= 10).optional(), "reqZeroMin": z.number().int().min(0).max(100), }); export type TopLevel = z.infer; diff --git a/base/schema-typescript-zod/test/inputs/schema/renaming-bug.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/renaming-bug.schema/default/TopLevel.ts index 040a94a..d1de348 100644 --- a/base/schema-typescript-zod/test/inputs/schema/renaming-bug.schema/default/TopLevel.ts +++ b/head/schema-typescript-zod/test/inputs/schema/renaming-bug.schema/default/TopLevel.ts @@ -78,7 +78,7 @@ export type Geometry = z.infer; export const VehicleSchema = z.object({ "brand": z.string().optional(), - "id": z.string().min(1).optional(), + "id": z.string().refine(value => Array.from(value).length >= 1).optional(), "speed": SpeedSchema.optional(), "subModule": z.boolean().optional(), "type": VehicleTypeSchema.optional(), @@ -94,7 +94,7 @@ export type Shape = z.infer; export const BerrySchema = z.object({ "color": ColorSchema.optional(), - "name": z.string().min(1).optional(), + "name": z.string().refine(value => Array.from(value).length >= 1).optional(), "shapes": z.array(ShapeSchema).optional(), }); export type Berry = z.infer; diff --git a/base/schema-typescript-zod/test/inputs/schema/schema-constraints.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/schema-constraints.schema/default/TopLevel.ts index d87842a..5f84104 100644 --- a/base/schema-typescript-zod/test/inputs/schema/schema-constraints.schema/default/TopLevel.ts +++ b/head/schema-typescript-zod/test/inputs/schema/schema-constraints.schema/default/TopLevel.ts @@ -2,7 +2,7 @@ import * as z from "zod"; export const TopLevelSchema = z.object({ - "minMaxLength": z.string().min(5).max(5), + "minMaxLength": z.string().refine(value => Array.from(value).length >= 5).refine(value => Array.from(value).length <= 5), "percent": z.number().min(0).max(1), }); export type TopLevel = z.infer; diff --git a/head/swift/test/inputs/json/priority/combinations1.json/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift b/head/swift/test/inputs/json/priority/combinations1.json/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift new file mode 100644 index 0000000..e124cd4 --- /dev/null +++ b/head/swift/test/inputs/json/priority/combinations1.json/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift @@ -0,0 +1,3182 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +import Foundation + +// MARK: - TopLevel +final class TopLevel: Codable { + let centrodesmose: String + let cerograph: [CerographElement] + let chemotherapeutics: [ChemotherapeuticElement] + let cimelia: [CimeliaElement] + let citrated: Int + let clinodome: [Clinodome] + let coadjust: [CoadjustElement] + let consilience: [Consilience] + let constructor: [Constructor] + let continuative: [Continuative] + let credulity: [CredulityElement] + let creviced: [Creviced] + let cubiculum: [[Int?]] + let deruralize: [DeruralizeElement] + let diaereses: [DiaereseElement] + let dissolution: [[JSONNull?]?] + let downstroke: [Downstroke] + let electrotautomerism: [Double?] + let eleutheromania: [Eleutheromania] + let encrust: Encrust + let entomoid: [Entomoid] + let epipaleolithic: [Epipaleolithic] + let expropriable: [Expropriable] + let faggingly: [FagginglyElement] + let fenks: [FenkElement] + let flagmaking: [FlagmakingElement] + let fluorometer: [Fluorometer] + let fulsome: [Int?] + let fuzzy: [Fuzzy] + let gardenwards: [Gardenward] + let generalissimo: [Generalissimo] + let habeas: [[String: Int]?] + let hemicrystalline: [Hemicrystalline] + let hemocoele: [HemocoeleElement] + let hoister: [Hoister] + let hyperpiesis: [Hyperpiesi] + let hyppish: [Hyppish] + let idealizer: [Idealizer] + let incrustator: [Incrustator] + let intentiveness: [Intentiveness] + let interacinar: Interacinar + let intercorrelation: [[Int]?] + let jacutinga: [Jacutinga] + + enum CodingKeys: String, CodingKey { + case centrodesmose = "centrodesmose" + case cerograph = "cerograph" + case chemotherapeutics = "chemotherapeutics" + case cimelia = "cimelia" + case citrated = "citrated" + case clinodome = "clinodome" + case coadjust = "coadjust" + case consilience = "consilience" + case constructor = "constructor" + case continuative = "continuative" + case credulity = "credulity" + case creviced = "creviced" + case cubiculum = "cubiculum" + case deruralize = "deruralize" + case diaereses = "diaereses" + case dissolution = "dissolution" + case downstroke = "downstroke" + case electrotautomerism = "electrotautomerism" + case eleutheromania = "eleutheromania" + case encrust = "encrust" + case entomoid = "entomoid" + case epipaleolithic = "epipaleolithic" + case expropriable = "expropriable" + case faggingly = "faggingly" + case fenks = "fenks" + case flagmaking = "flagmaking" + case fluorometer = "fluorometer" + case fulsome = "fulsome" + case fuzzy = "fuzzy" + case gardenwards = "gardenwards" + case generalissimo = "generalissimo" + case habeas = "habeas" + case hemicrystalline = "hemicrystalline" + case hemocoele = "hemocoele" + case hoister = "hoister" + case hyperpiesis = "hyperpiesis" + case hyppish = "hyppish" + case idealizer = "idealizer" + case incrustator = "incrustator" + case intentiveness = "intentiveness" + case interacinar = "interacinar" + case intercorrelation = "intercorrelation" + case jacutinga = "jacutinga" + } + + init(centrodesmose: String, cerograph: [CerographElement], chemotherapeutics: [ChemotherapeuticElement], cimelia: [CimeliaElement], citrated: Int, clinodome: [Clinodome], coadjust: [CoadjustElement], consilience: [Consilience], constructor: [Constructor], continuative: [Continuative], credulity: [CredulityElement], creviced: [Creviced], cubiculum: [[Int?]], deruralize: [DeruralizeElement], diaereses: [DiaereseElement], dissolution: [[JSONNull?]?], downstroke: [Downstroke], electrotautomerism: [Double?], eleutheromania: [Eleutheromania], encrust: Encrust, entomoid: [Entomoid], epipaleolithic: [Epipaleolithic], expropriable: [Expropriable], faggingly: [FagginglyElement], fenks: [FenkElement], flagmaking: [FlagmakingElement], fluorometer: [Fluorometer], fulsome: [Int?], fuzzy: [Fuzzy], gardenwards: [Gardenward], generalissimo: [Generalissimo], habeas: [[String: Int]?], hemicrystalline: [Hemicrystalline], hemocoele: [HemocoeleElement], hoister: [Hoister], hyperpiesis: [Hyperpiesi], hyppish: [Hyppish], idealizer: [Idealizer], incrustator: [Incrustator], intentiveness: [Intentiveness], interacinar: Interacinar, intercorrelation: [[Int]?], jacutinga: [Jacutinga]) { + self.centrodesmose = centrodesmose + self.cerograph = cerograph + self.chemotherapeutics = chemotherapeutics + self.cimelia = cimelia + self.citrated = citrated + self.clinodome = clinodome + self.coadjust = coadjust + self.consilience = consilience + self.constructor = constructor + self.continuative = continuative + self.credulity = credulity + self.creviced = creviced + self.cubiculum = cubiculum + self.deruralize = deruralize + self.diaereses = diaereses + self.dissolution = dissolution + self.downstroke = downstroke + self.electrotautomerism = electrotautomerism + self.eleutheromania = eleutheromania + self.encrust = encrust + self.entomoid = entomoid + self.epipaleolithic = epipaleolithic + self.expropriable = expropriable + self.faggingly = faggingly + self.fenks = fenks + self.flagmaking = flagmaking + self.fluorometer = fluorometer + self.fulsome = fulsome + self.fuzzy = fuzzy + self.gardenwards = gardenwards + self.generalissimo = generalissimo + self.habeas = habeas + self.hemicrystalline = hemicrystalline + self.hemocoele = hemocoele + self.hoister = hoister + self.hyperpiesis = hyperpiesis + self.hyppish = hyppish + self.idealizer = idealizer + self.incrustator = incrustator + self.intentiveness = intentiveness + self.interacinar = interacinar + self.intercorrelation = intercorrelation + self.jacutinga = jacutinga + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(TopLevel.self, from: data) + self.init(centrodesmose: me.centrodesmose, cerograph: me.cerograph, chemotherapeutics: me.chemotherapeutics, cimelia: me.cimelia, citrated: me.citrated, clinodome: me.clinodome, coadjust: me.coadjust, consilience: me.consilience, constructor: me.constructor, continuative: me.continuative, credulity: me.credulity, creviced: me.creviced, cubiculum: me.cubiculum, deruralize: me.deruralize, diaereses: me.diaereses, dissolution: me.dissolution, downstroke: me.downstroke, electrotautomerism: me.electrotautomerism, eleutheromania: me.eleutheromania, encrust: me.encrust, entomoid: me.entomoid, epipaleolithic: me.epipaleolithic, expropriable: me.expropriable, faggingly: me.faggingly, fenks: me.fenks, flagmaking: me.flagmaking, fluorometer: me.fluorometer, fulsome: me.fulsome, fuzzy: me.fuzzy, gardenwards: me.gardenwards, generalissimo: me.generalissimo, habeas: me.habeas, hemicrystalline: me.hemicrystalline, hemocoele: me.hemocoele, hoister: me.hoister, hyperpiesis: me.hyperpiesis, hyppish: me.hyppish, idealizer: me.idealizer, incrustator: me.incrustator, intentiveness: me.intentiveness, interacinar: me.interacinar, intercorrelation: me.intercorrelation, jacutinga: me.jacutinga) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + centrodesmose: String? = nil, + cerograph: [CerographElement]? = nil, + chemotherapeutics: [ChemotherapeuticElement]? = nil, + cimelia: [CimeliaElement]? = nil, + citrated: Int? = nil, + clinodome: [Clinodome]? = nil, + coadjust: [CoadjustElement]? = nil, + consilience: [Consilience]? = nil, + constructor: [Constructor]? = nil, + continuative: [Continuative]? = nil, + credulity: [CredulityElement]? = nil, + creviced: [Creviced]? = nil, + cubiculum: [[Int?]]? = nil, + deruralize: [DeruralizeElement]? = nil, + diaereses: [DiaereseElement]? = nil, + dissolution: [[JSONNull?]?]? = nil, + downstroke: [Downstroke]? = nil, + electrotautomerism: [Double?]? = nil, + eleutheromania: [Eleutheromania]? = nil, + encrust: Encrust? = nil, + entomoid: [Entomoid]? = nil, + epipaleolithic: [Epipaleolithic]? = nil, + expropriable: [Expropriable]? = nil, + faggingly: [FagginglyElement]? = nil, + fenks: [FenkElement]? = nil, + flagmaking: [FlagmakingElement]? = nil, + fluorometer: [Fluorometer]? = nil, + fulsome: [Int?]? = nil, + fuzzy: [Fuzzy]? = nil, + gardenwards: [Gardenward]? = nil, + generalissimo: [Generalissimo]? = nil, + habeas: [[String: Int]?]? = nil, + hemicrystalline: [Hemicrystalline]? = nil, + hemocoele: [HemocoeleElement]? = nil, + hoister: [Hoister]? = nil, + hyperpiesis: [Hyperpiesi]? = nil, + hyppish: [Hyppish]? = nil, + idealizer: [Idealizer]? = nil, + incrustator: [Incrustator]? = nil, + intentiveness: [Intentiveness]? = nil, + interacinar: Interacinar? = nil, + intercorrelation: [[Int]?]? = nil, + jacutinga: [Jacutinga]? = nil + ) -> TopLevel { + return TopLevel( + centrodesmose: centrodesmose ?? self.centrodesmose, + cerograph: cerograph ?? self.cerograph, + chemotherapeutics: chemotherapeutics ?? self.chemotherapeutics, + cimelia: cimelia ?? self.cimelia, + citrated: citrated ?? self.citrated, + clinodome: clinodome ?? self.clinodome, + coadjust: coadjust ?? self.coadjust, + consilience: consilience ?? self.consilience, + constructor: constructor ?? self.constructor, + continuative: continuative ?? self.continuative, + credulity: credulity ?? self.credulity, + creviced: creviced ?? self.creviced, + cubiculum: cubiculum ?? self.cubiculum, + deruralize: deruralize ?? self.deruralize, + diaereses: diaereses ?? self.diaereses, + dissolution: dissolution ?? self.dissolution, + downstroke: downstroke ?? self.downstroke, + electrotautomerism: electrotautomerism ?? self.electrotautomerism, + eleutheromania: eleutheromania ?? self.eleutheromania, + encrust: encrust ?? self.encrust, + entomoid: entomoid ?? self.entomoid, + epipaleolithic: epipaleolithic ?? self.epipaleolithic, + expropriable: expropriable ?? self.expropriable, + faggingly: faggingly ?? self.faggingly, + fenks: fenks ?? self.fenks, + flagmaking: flagmaking ?? self.flagmaking, + fluorometer: fluorometer ?? self.fluorometer, + fulsome: fulsome ?? self.fulsome, + fuzzy: fuzzy ?? self.fuzzy, + gardenwards: gardenwards ?? self.gardenwards, + generalissimo: generalissimo ?? self.generalissimo, + habeas: habeas ?? self.habeas, + hemicrystalline: hemicrystalline ?? self.hemicrystalline, + hemocoele: hemocoele ?? self.hemocoele, + hoister: hoister ?? self.hoister, + hyperpiesis: hyperpiesis ?? self.hyperpiesis, + hyppish: hyppish ?? self.hyppish, + idealizer: idealizer ?? self.idealizer, + incrustator: incrustator ?? self.incrustator, + intentiveness: intentiveness ?? self.intentiveness, + interacinar: interacinar ?? self.interacinar, + intercorrelation: intercorrelation ?? self.intercorrelation, + jacutinga: jacutinga ?? self.jacutinga + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum CerographElement: Codable { + case cerographClass(CerographClass) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CerographClass.self) { + self = .cerographClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(CerographElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CerographElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cerographClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - CerographClass +final class CerographClass: Codable { + let apotropaion: JSONNull? + let casuary: JSONNull? + let creaker: JSONNull? + let disqualification: JSONNull? + let imperatorious: JSONNull? + let impermeabilize: JSONNull? + let metastoma: JSONNull? + let noctidiurnal: JSONNull? + let nonreserve: JSONNull? + let ophthalmotonometry: JSONNull? + let pailful: JSONNull? + let pigfish: JSONNull? + let pongee: JSONNull? + let prosodical: JSONNull? + let scrofuloderm: JSONNull? + let storekeeping: JSONNull? + let therologist: JSONNull? + let tolowa: JSONNull? + let tradeful: JSONNull? + let unriveting: JSONNull? + + enum CodingKeys: String, CodingKey { + case apotropaion = "apotropaion" + case casuary = "casuary" + case creaker = "creaker" + case disqualification = "disqualification" + case imperatorious = "imperatorious" + case impermeabilize = "impermeabilize" + case metastoma = "metastoma" + case noctidiurnal = "noctidiurnal" + case nonreserve = "nonreserve" + case ophthalmotonometry = "ophthalmotonometry" + case pailful = "pailful" + case pigfish = "pigfish" + case pongee = "pongee" + case prosodical = "prosodical" + case scrofuloderm = "scrofuloderm" + case storekeeping = "storekeeping" + case therologist = "therologist" + case tolowa = "Tolowa" + case tradeful = "tradeful" + case unriveting = "unriveting" + } + + init(apotropaion: JSONNull?, casuary: JSONNull?, creaker: JSONNull?, disqualification: JSONNull?, imperatorious: JSONNull?, impermeabilize: JSONNull?, metastoma: JSONNull?, noctidiurnal: JSONNull?, nonreserve: JSONNull?, ophthalmotonometry: JSONNull?, pailful: JSONNull?, pigfish: JSONNull?, pongee: JSONNull?, prosodical: JSONNull?, scrofuloderm: JSONNull?, storekeeping: JSONNull?, therologist: JSONNull?, tolowa: JSONNull?, tradeful: JSONNull?, unriveting: JSONNull?) { + self.apotropaion = apotropaion + self.casuary = casuary + self.creaker = creaker + self.disqualification = disqualification + self.imperatorious = imperatorious + self.impermeabilize = impermeabilize + self.metastoma = metastoma + self.noctidiurnal = noctidiurnal + self.nonreserve = nonreserve + self.ophthalmotonometry = ophthalmotonometry + self.pailful = pailful + self.pigfish = pigfish + self.pongee = pongee + self.prosodical = prosodical + self.scrofuloderm = scrofuloderm + self.storekeeping = storekeeping + self.therologist = therologist + self.tolowa = tolowa + self.tradeful = tradeful + self.unriveting = unriveting + } +} + +// MARK: CerographClass convenience initializers and mutators + +extension CerographClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(CerographClass.self, from: data) + self.init(apotropaion: me.apotropaion, casuary: me.casuary, creaker: me.creaker, disqualification: me.disqualification, imperatorious: me.imperatorious, impermeabilize: me.impermeabilize, metastoma: me.metastoma, noctidiurnal: me.noctidiurnal, nonreserve: me.nonreserve, ophthalmotonometry: me.ophthalmotonometry, pailful: me.pailful, pigfish: me.pigfish, pongee: me.pongee, prosodical: me.prosodical, scrofuloderm: me.scrofuloderm, storekeeping: me.storekeeping, therologist: me.therologist, tolowa: me.tolowa, tradeful: me.tradeful, unriveting: me.unriveting) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + apotropaion: JSONNull?? = nil, + casuary: JSONNull?? = nil, + creaker: JSONNull?? = nil, + disqualification: JSONNull?? = nil, + imperatorious: JSONNull?? = nil, + impermeabilize: JSONNull?? = nil, + metastoma: JSONNull?? = nil, + noctidiurnal: JSONNull?? = nil, + nonreserve: JSONNull?? = nil, + ophthalmotonometry: JSONNull?? = nil, + pailful: JSONNull?? = nil, + pigfish: JSONNull?? = nil, + pongee: JSONNull?? = nil, + prosodical: JSONNull?? = nil, + scrofuloderm: JSONNull?? = nil, + storekeeping: JSONNull?? = nil, + therologist: JSONNull?? = nil, + tolowa: JSONNull?? = nil, + tradeful: JSONNull?? = nil, + unriveting: JSONNull?? = nil + ) -> CerographClass { + return CerographClass( + apotropaion: apotropaion ?? self.apotropaion, + casuary: casuary ?? self.casuary, + creaker: creaker ?? self.creaker, + disqualification: disqualification ?? self.disqualification, + imperatorious: imperatorious ?? self.imperatorious, + impermeabilize: impermeabilize ?? self.impermeabilize, + metastoma: metastoma ?? self.metastoma, + noctidiurnal: noctidiurnal ?? self.noctidiurnal, + nonreserve: nonreserve ?? self.nonreserve, + ophthalmotonometry: ophthalmotonometry ?? self.ophthalmotonometry, + pailful: pailful ?? self.pailful, + pigfish: pigfish ?? self.pigfish, + pongee: pongee ?? self.pongee, + prosodical: prosodical ?? self.prosodical, + scrofuloderm: scrofuloderm ?? self.scrofuloderm, + storekeeping: storekeeping ?? self.storekeeping, + therologist: therologist ?? self.therologist, + tolowa: tolowa ?? self.tolowa, + tradeful: tradeful ?? self.tradeful, + unriveting: unriveting ?? self.unriveting + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum ChemotherapeuticElement: Codable { + case chemotherapeuticClass(ChemotherapeuticClass) + case integer(Int) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(ChemotherapeuticClass.self) { + self = .chemotherapeuticClass(x) + return + } + throw DecodingError.typeMismatch(ChemotherapeuticElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for ChemotherapeuticElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .chemotherapeuticClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + } + } +} + +// MARK: - ChemotherapeuticClass +final class ChemotherapeuticClass: Codable { + let angioneurotic: JSONNull? + let availment: JSONNull? + let bladelet: JSONNull? + let catharticalness: Double? + let caulis: JSONNull? + let chalcus: JSONNull? + let chirotherium: Int? + let disdiapason: String? + let enteradenological: JSONNull? + let homocerc: Bool? + let imporosity: JSONNull? + let insistently: JSONNull? + let intraparietal: JSONNull? + let ivied: JSONNull? + let maureen: JSONNull? + let nonbookish: JSONNull? + let nostochine: JSONNull? + let nutcracker: JSONNull? + let ofttimes: JSONNull? + let phenocryst: JSONNull? + let precoincident: JSONNull? + let ramiferous: JSONNull? + let stagmometer: JSONNull? + let tetherball: JSONNull? + let unshy: JSONNull? + + enum CodingKeys: String, CodingKey { + case angioneurotic = "angioneurotic" + case availment = "availment" + case bladelet = "bladelet" + case catharticalness = "catharticalness" + case caulis = "caulis" + case chalcus = "chalcus" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case enteradenological = "enteradenological" + case homocerc = "homocerc" + case imporosity = "imporosity" + case insistently = "insistently" + case intraparietal = "intraparietal" + case ivied = "ivied" + case maureen = "Maureen" + case nonbookish = "nonbookish" + case nostochine = "nostochine" + case nutcracker = "nutcracker" + case ofttimes = "ofttimes" + case phenocryst = "phenocryst" + case precoincident = "precoincident" + case ramiferous = "ramiferous" + case stagmometer = "stagmometer" + case tetherball = "tetherball" + case unshy = "unshy" + } + + init(angioneurotic: JSONNull?, availment: JSONNull?, bladelet: JSONNull?, catharticalness: Double?, caulis: JSONNull?, chalcus: JSONNull?, chirotherium: Int?, disdiapason: String?, enteradenological: JSONNull?, homocerc: Bool?, imporosity: JSONNull?, insistently: JSONNull?, intraparietal: JSONNull?, ivied: JSONNull?, maureen: JSONNull?, nonbookish: JSONNull?, nostochine: JSONNull?, nutcracker: JSONNull?, ofttimes: JSONNull?, phenocryst: JSONNull?, precoincident: JSONNull?, ramiferous: JSONNull?, stagmometer: JSONNull?, tetherball: JSONNull?, unshy: JSONNull?) { + self.angioneurotic = angioneurotic + self.availment = availment + self.bladelet = bladelet + self.catharticalness = catharticalness + self.caulis = caulis + self.chalcus = chalcus + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.enteradenological = enteradenological + self.homocerc = homocerc + self.imporosity = imporosity + self.insistently = insistently + self.intraparietal = intraparietal + self.ivied = ivied + self.maureen = maureen + self.nonbookish = nonbookish + self.nostochine = nostochine + self.nutcracker = nutcracker + self.ofttimes = ofttimes + self.phenocryst = phenocryst + self.precoincident = precoincident + self.ramiferous = ramiferous + self.stagmometer = stagmometer + self.tetherball = tetherball + self.unshy = unshy + } +} + +// MARK: ChemotherapeuticClass convenience initializers and mutators + +extension ChemotherapeuticClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(ChemotherapeuticClass.self, from: data) + self.init(angioneurotic: me.angioneurotic, availment: me.availment, bladelet: me.bladelet, catharticalness: me.catharticalness, caulis: me.caulis, chalcus: me.chalcus, chirotherium: me.chirotherium, disdiapason: me.disdiapason, enteradenological: me.enteradenological, homocerc: me.homocerc, imporosity: me.imporosity, insistently: me.insistently, intraparietal: me.intraparietal, ivied: me.ivied, maureen: me.maureen, nonbookish: me.nonbookish, nostochine: me.nostochine, nutcracker: me.nutcracker, ofttimes: me.ofttimes, phenocryst: me.phenocryst, precoincident: me.precoincident, ramiferous: me.ramiferous, stagmometer: me.stagmometer, tetherball: me.tetherball, unshy: me.unshy) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + angioneurotic: JSONNull?? = nil, + availment: JSONNull?? = nil, + bladelet: JSONNull?? = nil, + catharticalness: Double?? = nil, + caulis: JSONNull?? = nil, + chalcus: JSONNull?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + enteradenological: JSONNull?? = nil, + homocerc: Bool?? = nil, + imporosity: JSONNull?? = nil, + insistently: JSONNull?? = nil, + intraparietal: JSONNull?? = nil, + ivied: JSONNull?? = nil, + maureen: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + nostochine: JSONNull?? = nil, + nutcracker: JSONNull?? = nil, + ofttimes: JSONNull?? = nil, + phenocryst: JSONNull?? = nil, + precoincident: JSONNull?? = nil, + ramiferous: JSONNull?? = nil, + stagmometer: JSONNull?? = nil, + tetherball: JSONNull?? = nil, + unshy: JSONNull?? = nil + ) -> ChemotherapeuticClass { + return ChemotherapeuticClass( + angioneurotic: angioneurotic ?? self.angioneurotic, + availment: availment ?? self.availment, + bladelet: bladelet ?? self.bladelet, + catharticalness: catharticalness ?? self.catharticalness, + caulis: caulis ?? self.caulis, + chalcus: chalcus ?? self.chalcus, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + enteradenological: enteradenological ?? self.enteradenological, + homocerc: homocerc ?? self.homocerc, + imporosity: imporosity ?? self.imporosity, + insistently: insistently ?? self.insistently, + intraparietal: intraparietal ?? self.intraparietal, + ivied: ivied ?? self.ivied, + maureen: maureen ?? self.maureen, + nonbookish: nonbookish ?? self.nonbookish, + nostochine: nostochine ?? self.nostochine, + nutcracker: nutcracker ?? self.nutcracker, + ofttimes: ofttimes ?? self.ofttimes, + phenocryst: phenocryst ?? self.phenocryst, + precoincident: precoincident ?? self.precoincident, + ramiferous: ramiferous ?? self.ramiferous, + stagmometer: stagmometer ?? self.stagmometer, + tetherball: tetherball ?? self.tetherball, + unshy: unshy ?? self.unshy + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum CimeliaElement: Codable { + case cimeliaClass(CimeliaClass) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(CimeliaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CimeliaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - CimeliaClass +final class CimeliaClass: Codable { + let catharticalness: Double + let chirotherium: Int + let disdiapason: String + let homocerc: Bool + let nonbookish: JSONNull? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case homocerc = "homocerc" + case nonbookish = "nonbookish" + } + + init(catharticalness: Double, chirotherium: Int, disdiapason: String, homocerc: Bool, nonbookish: JSONNull?) { + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.homocerc = homocerc + self.nonbookish = nonbookish + } +} + +// MARK: CimeliaClass convenience initializers and mutators + +extension CimeliaClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(CimeliaClass.self, from: data) + self.init(catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, homocerc: me.homocerc, nonbookish: me.nonbookish) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double? = nil, + chirotherium: Int? = nil, + disdiapason: String? = nil, + homocerc: Bool? = nil, + nonbookish: JSONNull?? = nil + ) -> CimeliaClass { + return CimeliaClass( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + homocerc: homocerc ?? self.homocerc, + nonbookish: nonbookish ?? self.nonbookish + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Clinodome: Codable { + case double(Double) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Clinodome.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Clinodome")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum CoadjustElement: Codable { + case coadjustClass(CoadjustClass) + case double(Double) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(CoadjustClass.self) { + self = .coadjustClass(x) + return + } + throw DecodingError.typeMismatch(CoadjustElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CoadjustElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .coadjustClass(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + } + } +} + +// MARK: - CoadjustClass +final class CoadjustClass: Codable { + let amidosulphonal: JSONNull? + let benny: JSONNull? + let catharticalness: Double? + let chirotherium: Int? + let disdiapason: String? + let ensnare: JSONNull? + let homocerc: Bool? + let hybridizer: JSONNull? + let leastwise: JSONNull? + let lof: JSONNull? + let monkhood: JSONNull? + let netherlandish: JSONNull? + let nonbookish: JSONNull? + let peonism: JSONNull? + let phonelescope: JSONNull? + let porphyrogeniture: JSONNull? + let preindemnify: JSONNull? + let rosal: JSONNull? + let scalenous: JSONNull? + let scopine: JSONNull? + let sedaceae: JSONNull? + let suberinize: JSONNull? + let symbiot: JSONNull? + let tablefellow: JSONNull? + let unchargeable: JSONNull? + + enum CodingKeys: String, CodingKey { + case amidosulphonal = "amidosulphonal" + case benny = "Benny" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case ensnare = "ensnare" + case homocerc = "homocerc" + case hybridizer = "hybridizer" + case leastwise = "leastwise" + case lof = "lof" + case monkhood = "monkhood" + case netherlandish = "Netherlandish" + case nonbookish = "nonbookish" + case peonism = "peonism" + case phonelescope = "Phonelescope" + case porphyrogeniture = "porphyrogeniture" + case preindemnify = "preindemnify" + case rosal = "rosal" + case scalenous = "scalenous" + case scopine = "scopine" + case sedaceae = "Sedaceae" + case suberinize = "suberinize" + case symbiot = "symbiot" + case tablefellow = "tablefellow" + case unchargeable = "unchargeable" + } + + init(amidosulphonal: JSONNull?, benny: JSONNull?, catharticalness: Double?, chirotherium: Int?, disdiapason: String?, ensnare: JSONNull?, homocerc: Bool?, hybridizer: JSONNull?, leastwise: JSONNull?, lof: JSONNull?, monkhood: JSONNull?, netherlandish: JSONNull?, nonbookish: JSONNull?, peonism: JSONNull?, phonelescope: JSONNull?, porphyrogeniture: JSONNull?, preindemnify: JSONNull?, rosal: JSONNull?, scalenous: JSONNull?, scopine: JSONNull?, sedaceae: JSONNull?, suberinize: JSONNull?, symbiot: JSONNull?, tablefellow: JSONNull?, unchargeable: JSONNull?) { + self.amidosulphonal = amidosulphonal + self.benny = benny + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.ensnare = ensnare + self.homocerc = homocerc + self.hybridizer = hybridizer + self.leastwise = leastwise + self.lof = lof + self.monkhood = monkhood + self.netherlandish = netherlandish + self.nonbookish = nonbookish + self.peonism = peonism + self.phonelescope = phonelescope + self.porphyrogeniture = porphyrogeniture + self.preindemnify = preindemnify + self.rosal = rosal + self.scalenous = scalenous + self.scopine = scopine + self.sedaceae = sedaceae + self.suberinize = suberinize + self.symbiot = symbiot + self.tablefellow = tablefellow + self.unchargeable = unchargeable + } +} + +// MARK: CoadjustClass convenience initializers and mutators + +extension CoadjustClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(CoadjustClass.self, from: data) + self.init(amidosulphonal: me.amidosulphonal, benny: me.benny, catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, ensnare: me.ensnare, homocerc: me.homocerc, hybridizer: me.hybridizer, leastwise: me.leastwise, lof: me.lof, monkhood: me.monkhood, netherlandish: me.netherlandish, nonbookish: me.nonbookish, peonism: me.peonism, phonelescope: me.phonelescope, porphyrogeniture: me.porphyrogeniture, preindemnify: me.preindemnify, rosal: me.rosal, scalenous: me.scalenous, scopine: me.scopine, sedaceae: me.sedaceae, suberinize: me.suberinize, symbiot: me.symbiot, tablefellow: me.tablefellow, unchargeable: me.unchargeable) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + amidosulphonal: JSONNull?? = nil, + benny: JSONNull?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + ensnare: JSONNull?? = nil, + homocerc: Bool?? = nil, + hybridizer: JSONNull?? = nil, + leastwise: JSONNull?? = nil, + lof: JSONNull?? = nil, + monkhood: JSONNull?? = nil, + netherlandish: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + peonism: JSONNull?? = nil, + phonelescope: JSONNull?? = nil, + porphyrogeniture: JSONNull?? = nil, + preindemnify: JSONNull?? = nil, + rosal: JSONNull?? = nil, + scalenous: JSONNull?? = nil, + scopine: JSONNull?? = nil, + sedaceae: JSONNull?? = nil, + suberinize: JSONNull?? = nil, + symbiot: JSONNull?? = nil, + tablefellow: JSONNull?? = nil, + unchargeable: JSONNull?? = nil + ) -> CoadjustClass { + return CoadjustClass( + amidosulphonal: amidosulphonal ?? self.amidosulphonal, + benny: benny ?? self.benny, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + ensnare: ensnare ?? self.ensnare, + homocerc: homocerc ?? self.homocerc, + hybridizer: hybridizer ?? self.hybridizer, + leastwise: leastwise ?? self.leastwise, + lof: lof ?? self.lof, + monkhood: monkhood ?? self.monkhood, + netherlandish: netherlandish ?? self.netherlandish, + nonbookish: nonbookish ?? self.nonbookish, + peonism: peonism ?? self.peonism, + phonelescope: phonelescope ?? self.phonelescope, + porphyrogeniture: porphyrogeniture ?? self.porphyrogeniture, + preindemnify: preindemnify ?? self.preindemnify, + rosal: rosal ?? self.rosal, + scalenous: scalenous ?? self.scalenous, + scopine: scopine ?? self.scopine, + sedaceae: sedaceae ?? self.sedaceae, + suberinize: suberinize ?? self.suberinize, + symbiot: symbiot ?? self.symbiot, + tablefellow: tablefellow ?? self.tablefellow, + unchargeable: unchargeable ?? self.unchargeable + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Consilience: Codable { + case double(Double) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Consilience.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Consilience")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Constructor: Codable { + case bool(Bool) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Constructor.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Constructor")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +enum Continuative: Codable { + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Continuative.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Continuative")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum CredulityElement: Codable { + case credulityClass(CredulityClass) + case integer(Int) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CredulityClass.self) { + self = .credulityClass(x) + return + } + throw DecodingError.typeMismatch(CredulityElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CredulityElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .credulityClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - CredulityClass +final class CredulityClass: Codable { + let ammonolytic: JSONNull? + let bushmaster: JSONNull? + let considering: JSONNull? + let consuetudinary: JSONNull? + let embarras: JSONNull? + let fineness: JSONNull? + let flaithship: JSONNull? + let flavia: JSONNull? + let gruffly: JSONNull? + let hedychium: JSONNull? + let leadwort: JSONNull? + let overseriously: JSONNull? + let parabola: JSONNull? + let pectinatodenticulate: JSONNull? + let popean: JSONNull? + let pornocrat: JSONNull? + let quadrisect: JSONNull? + let seriality: JSONNull? + let vamphorn: JSONNull? + let wharp: JSONNull? + + enum CodingKeys: String, CodingKey { + case ammonolytic = "ammonolytic" + case bushmaster = "bushmaster" + case considering = "considering" + case consuetudinary = "consuetudinary" + case embarras = "embarras" + case fineness = "fineness" + case flaithship = "flaithship" + case flavia = "Flavia" + case gruffly = "gruffly" + case hedychium = "Hedychium" + case leadwort = "leadwort" + case overseriously = "overseriously" + case parabola = "parabola" + case pectinatodenticulate = "pectinatodenticulate" + case popean = "Popean" + case pornocrat = "pornocrat" + case quadrisect = "quadrisect" + case seriality = "seriality" + case vamphorn = "vamphorn" + case wharp = "wharp" + } + + init(ammonolytic: JSONNull?, bushmaster: JSONNull?, considering: JSONNull?, consuetudinary: JSONNull?, embarras: JSONNull?, fineness: JSONNull?, flaithship: JSONNull?, flavia: JSONNull?, gruffly: JSONNull?, hedychium: JSONNull?, leadwort: JSONNull?, overseriously: JSONNull?, parabola: JSONNull?, pectinatodenticulate: JSONNull?, popean: JSONNull?, pornocrat: JSONNull?, quadrisect: JSONNull?, seriality: JSONNull?, vamphorn: JSONNull?, wharp: JSONNull?) { + self.ammonolytic = ammonolytic + self.bushmaster = bushmaster + self.considering = considering + self.consuetudinary = consuetudinary + self.embarras = embarras + self.fineness = fineness + self.flaithship = flaithship + self.flavia = flavia + self.gruffly = gruffly + self.hedychium = hedychium + self.leadwort = leadwort + self.overseriously = overseriously + self.parabola = parabola + self.pectinatodenticulate = pectinatodenticulate + self.popean = popean + self.pornocrat = pornocrat + self.quadrisect = quadrisect + self.seriality = seriality + self.vamphorn = vamphorn + self.wharp = wharp + } +} + +// MARK: CredulityClass convenience initializers and mutators + +extension CredulityClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(CredulityClass.self, from: data) + self.init(ammonolytic: me.ammonolytic, bushmaster: me.bushmaster, considering: me.considering, consuetudinary: me.consuetudinary, embarras: me.embarras, fineness: me.fineness, flaithship: me.flaithship, flavia: me.flavia, gruffly: me.gruffly, hedychium: me.hedychium, leadwort: me.leadwort, overseriously: me.overseriously, parabola: me.parabola, pectinatodenticulate: me.pectinatodenticulate, popean: me.popean, pornocrat: me.pornocrat, quadrisect: me.quadrisect, seriality: me.seriality, vamphorn: me.vamphorn, wharp: me.wharp) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + ammonolytic: JSONNull?? = nil, + bushmaster: JSONNull?? = nil, + considering: JSONNull?? = nil, + consuetudinary: JSONNull?? = nil, + embarras: JSONNull?? = nil, + fineness: JSONNull?? = nil, + flaithship: JSONNull?? = nil, + flavia: JSONNull?? = nil, + gruffly: JSONNull?? = nil, + hedychium: JSONNull?? = nil, + leadwort: JSONNull?? = nil, + overseriously: JSONNull?? = nil, + parabola: JSONNull?? = nil, + pectinatodenticulate: JSONNull?? = nil, + popean: JSONNull?? = nil, + pornocrat: JSONNull?? = nil, + quadrisect: JSONNull?? = nil, + seriality: JSONNull?? = nil, + vamphorn: JSONNull?? = nil, + wharp: JSONNull?? = nil + ) -> CredulityClass { + return CredulityClass( + ammonolytic: ammonolytic ?? self.ammonolytic, + bushmaster: bushmaster ?? self.bushmaster, + considering: considering ?? self.considering, + consuetudinary: consuetudinary ?? self.consuetudinary, + embarras: embarras ?? self.embarras, + fineness: fineness ?? self.fineness, + flaithship: flaithship ?? self.flaithship, + flavia: flavia ?? self.flavia, + gruffly: gruffly ?? self.gruffly, + hedychium: hedychium ?? self.hedychium, + leadwort: leadwort ?? self.leadwort, + overseriously: overseriously ?? self.overseriously, + parabola: parabola ?? self.parabola, + pectinatodenticulate: pectinatodenticulate ?? self.pectinatodenticulate, + popean: popean ?? self.popean, + pornocrat: pornocrat ?? self.pornocrat, + quadrisect: quadrisect ?? self.quadrisect, + seriality: seriality ?? self.seriality, + vamphorn: vamphorn ?? self.vamphorn, + wharp: wharp ?? self.wharp + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Creviced: Codable { + case bool(Bool) + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Creviced.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Creviced")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum DeruralizeElement: Codable { + case bool(Bool) + case deruralizeClass(DeruralizeClass) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(DeruralizeClass.self) { + self = .deruralizeClass(x) + return + } + throw DecodingError.typeMismatch(DeruralizeElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for DeruralizeElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .deruralizeClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +// MARK: - DeruralizeClass +final class DeruralizeClass: Codable { + let bockerel: JSONNull? + let boulder: JSONNull? + let churrus: JSONNull? + let counterdigged: JSONNull? + let dialogite: JSONNull? + let digenic: JSONNull? + let dunbird: JSONNull? + let ergatogyne: JSONNull? + let fiendful: JSONNull? + let jackrod: JSONNull? + let jehovistic: JSONNull? + let paninean: JSONNull? + let panther: JSONNull? + let placentigerous: JSONNull? + let romney: JSONNull? + let sparm: JSONNull? + let tocsin: JSONNull? + let unnicked: JSONNull? + let unstavable: JSONNull? + let windfirm: JSONNull? + + enum CodingKeys: String, CodingKey { + case bockerel = "bockerel" + case boulder = "boulder" + case churrus = "churrus" + case counterdigged = "counterdigged" + case dialogite = "dialogite" + case digenic = "digenic" + case dunbird = "dunbird" + case ergatogyne = "ergatogyne" + case fiendful = "fiendful" + case jackrod = "jackrod" + case jehovistic = "Jehovistic" + case paninean = "Paninean" + case panther = "panther" + case placentigerous = "placentigerous" + case romney = "Romney" + case sparm = "sparm" + case tocsin = "tocsin" + case unnicked = "unnicked" + case unstavable = "unstavable" + case windfirm = "windfirm" + } + + init(bockerel: JSONNull?, boulder: JSONNull?, churrus: JSONNull?, counterdigged: JSONNull?, dialogite: JSONNull?, digenic: JSONNull?, dunbird: JSONNull?, ergatogyne: JSONNull?, fiendful: JSONNull?, jackrod: JSONNull?, jehovistic: JSONNull?, paninean: JSONNull?, panther: JSONNull?, placentigerous: JSONNull?, romney: JSONNull?, sparm: JSONNull?, tocsin: JSONNull?, unnicked: JSONNull?, unstavable: JSONNull?, windfirm: JSONNull?) { + self.bockerel = bockerel + self.boulder = boulder + self.churrus = churrus + self.counterdigged = counterdigged + self.dialogite = dialogite + self.digenic = digenic + self.dunbird = dunbird + self.ergatogyne = ergatogyne + self.fiendful = fiendful + self.jackrod = jackrod + self.jehovistic = jehovistic + self.paninean = paninean + self.panther = panther + self.placentigerous = placentigerous + self.romney = romney + self.sparm = sparm + self.tocsin = tocsin + self.unnicked = unnicked + self.unstavable = unstavable + self.windfirm = windfirm + } +} + +// MARK: DeruralizeClass convenience initializers and mutators + +extension DeruralizeClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(DeruralizeClass.self, from: data) + self.init(bockerel: me.bockerel, boulder: me.boulder, churrus: me.churrus, counterdigged: me.counterdigged, dialogite: me.dialogite, digenic: me.digenic, dunbird: me.dunbird, ergatogyne: me.ergatogyne, fiendful: me.fiendful, jackrod: me.jackrod, jehovistic: me.jehovistic, paninean: me.paninean, panther: me.panther, placentigerous: me.placentigerous, romney: me.romney, sparm: me.sparm, tocsin: me.tocsin, unnicked: me.unnicked, unstavable: me.unstavable, windfirm: me.windfirm) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + bockerel: JSONNull?? = nil, + boulder: JSONNull?? = nil, + churrus: JSONNull?? = nil, + counterdigged: JSONNull?? = nil, + dialogite: JSONNull?? = nil, + digenic: JSONNull?? = nil, + dunbird: JSONNull?? = nil, + ergatogyne: JSONNull?? = nil, + fiendful: JSONNull?? = nil, + jackrod: JSONNull?? = nil, + jehovistic: JSONNull?? = nil, + paninean: JSONNull?? = nil, + panther: JSONNull?? = nil, + placentigerous: JSONNull?? = nil, + romney: JSONNull?? = nil, + sparm: JSONNull?? = nil, + tocsin: JSONNull?? = nil, + unnicked: JSONNull?? = nil, + unstavable: JSONNull?? = nil, + windfirm: JSONNull?? = nil + ) -> DeruralizeClass { + return DeruralizeClass( + bockerel: bockerel ?? self.bockerel, + boulder: boulder ?? self.boulder, + churrus: churrus ?? self.churrus, + counterdigged: counterdigged ?? self.counterdigged, + dialogite: dialogite ?? self.dialogite, + digenic: digenic ?? self.digenic, + dunbird: dunbird ?? self.dunbird, + ergatogyne: ergatogyne ?? self.ergatogyne, + fiendful: fiendful ?? self.fiendful, + jackrod: jackrod ?? self.jackrod, + jehovistic: jehovistic ?? self.jehovistic, + paninean: paninean ?? self.paninean, + panther: panther ?? self.panther, + placentigerous: placentigerous ?? self.placentigerous, + romney: romney ?? self.romney, + sparm: sparm ?? self.sparm, + tocsin: tocsin ?? self.tocsin, + unnicked: unnicked ?? self.unnicked, + unstavable: unstavable ?? self.unstavable, + windfirm: windfirm ?? self.windfirm + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum DiaereseElement: Codable { + case bool(Bool) + case diaereseClass(DiaereseClass) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(DiaereseClass.self) { + self = .diaereseClass(x) + return + } + throw DecodingError.typeMismatch(DiaereseElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for DiaereseElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .diaereseClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +// MARK: - DiaereseClass +final class DiaereseClass: Codable { + let amoreuxia: JSONNull? + let ani: JSONNull? + let bernicle: JSONNull? + let blackwasher: JSONNull? + let blowhard: JSONNull? + let broma: JSONNull? + let closecross: JSONNull? + let congregationalism: JSONNull? + let grayly: JSONNull? + let historically: JSONNull? + let hoast: JSONNull? + let irretentive: JSONNull? + let parcener: JSONNull? + let pedder: JSONNull? + let pseudoanatomic: JSONNull? + let rhizocarpian: JSONNull? + let samel: JSONNull? + let silker: JSONNull? + let subdentated: JSONNull? + let subobscure: JSONNull? + + enum CodingKeys: String, CodingKey { + case amoreuxia = "Amoreuxia" + case ani = "ani" + case bernicle = "bernicle" + case blackwasher = "blackwasher" + case blowhard = "blowhard" + case broma = "broma" + case closecross = "closecross" + case congregationalism = "congregationalism" + case grayly = "grayly" + case historically = "historically" + case hoast = "hoast" + case irretentive = "irretentive" + case parcener = "parcener" + case pedder = "pedder" + case pseudoanatomic = "pseudoanatomic" + case rhizocarpian = "rhizocarpian" + case samel = "samel" + case silker = "silker" + case subdentated = "subdentated" + case subobscure = "subobscure" + } + + init(amoreuxia: JSONNull?, ani: JSONNull?, bernicle: JSONNull?, blackwasher: JSONNull?, blowhard: JSONNull?, broma: JSONNull?, closecross: JSONNull?, congregationalism: JSONNull?, grayly: JSONNull?, historically: JSONNull?, hoast: JSONNull?, irretentive: JSONNull?, parcener: JSONNull?, pedder: JSONNull?, pseudoanatomic: JSONNull?, rhizocarpian: JSONNull?, samel: JSONNull?, silker: JSONNull?, subdentated: JSONNull?, subobscure: JSONNull?) { + self.amoreuxia = amoreuxia + self.ani = ani + self.bernicle = bernicle + self.blackwasher = blackwasher + self.blowhard = blowhard + self.broma = broma + self.closecross = closecross + self.congregationalism = congregationalism + self.grayly = grayly + self.historically = historically + self.hoast = hoast + self.irretentive = irretentive + self.parcener = parcener + self.pedder = pedder + self.pseudoanatomic = pseudoanatomic + self.rhizocarpian = rhizocarpian + self.samel = samel + self.silker = silker + self.subdentated = subdentated + self.subobscure = subobscure + } +} + +// MARK: DiaereseClass convenience initializers and mutators + +extension DiaereseClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(DiaereseClass.self, from: data) + self.init(amoreuxia: me.amoreuxia, ani: me.ani, bernicle: me.bernicle, blackwasher: me.blackwasher, blowhard: me.blowhard, broma: me.broma, closecross: me.closecross, congregationalism: me.congregationalism, grayly: me.grayly, historically: me.historically, hoast: me.hoast, irretentive: me.irretentive, parcener: me.parcener, pedder: me.pedder, pseudoanatomic: me.pseudoanatomic, rhizocarpian: me.rhizocarpian, samel: me.samel, silker: me.silker, subdentated: me.subdentated, subobscure: me.subobscure) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + amoreuxia: JSONNull?? = nil, + ani: JSONNull?? = nil, + bernicle: JSONNull?? = nil, + blackwasher: JSONNull?? = nil, + blowhard: JSONNull?? = nil, + broma: JSONNull?? = nil, + closecross: JSONNull?? = nil, + congregationalism: JSONNull?? = nil, + grayly: JSONNull?? = nil, + historically: JSONNull?? = nil, + hoast: JSONNull?? = nil, + irretentive: JSONNull?? = nil, + parcener: JSONNull?? = nil, + pedder: JSONNull?? = nil, + pseudoanatomic: JSONNull?? = nil, + rhizocarpian: JSONNull?? = nil, + samel: JSONNull?? = nil, + silker: JSONNull?? = nil, + subdentated: JSONNull?? = nil, + subobscure: JSONNull?? = nil + ) -> DiaereseClass { + return DiaereseClass( + amoreuxia: amoreuxia ?? self.amoreuxia, + ani: ani ?? self.ani, + bernicle: bernicle ?? self.bernicle, + blackwasher: blackwasher ?? self.blackwasher, + blowhard: blowhard ?? self.blowhard, + broma: broma ?? self.broma, + closecross: closecross ?? self.closecross, + congregationalism: congregationalism ?? self.congregationalism, + grayly: grayly ?? self.grayly, + historically: historically ?? self.historically, + hoast: hoast ?? self.hoast, + irretentive: irretentive ?? self.irretentive, + parcener: parcener ?? self.parcener, + pedder: pedder ?? self.pedder, + pseudoanatomic: pseudoanatomic ?? self.pseudoanatomic, + rhizocarpian: rhizocarpian ?? self.rhizocarpian, + samel: samel ?? self.samel, + silker: silker ?? self.silker, + subdentated: subdentated ?? self.subdentated, + subobscure: subobscure ?? self.subobscure + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Downstroke: Codable { + case bool(Bool) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Downstroke.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Downstroke")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Eleutheromania: Codable { + case double(Double) + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Eleutheromania.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Eleutheromania")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - Encrust +final class Encrust: Codable { + let comradely: JSONNull? + let diacanthous: JSONNull? + let feminineness: JSONNull? + let gossamered: JSONNull? + let hibernia: JSONNull? + let hibiscus: JSONNull? + let lepidosauria: JSONNull? + let lollingly: JSONNull? + let manager: JSONNull? + let mechanic: JSONNull? + let overminuteness: JSONNull? + let papelonne: JSONNull? + let plebification: JSONNull? + let pugmiller: JSONNull? + let recoveror: JSONNull? + let spermatoblastic: JSONNull? + let syllidae: JSONNull? + let ungyved: JSONNull? + let whirlabout: JSONNull? + let woodenware: JSONNull? + + enum CodingKeys: String, CodingKey { + case comradely = "comradely" + case diacanthous = "diacanthous" + case feminineness = "feminineness" + case gossamered = "gossamered" + case hibernia = "Hibernia" + case hibiscus = "Hibiscus" + case lepidosauria = "Lepidosauria" + case lollingly = "lollingly" + case manager = "manager" + case mechanic = "mechanic" + case overminuteness = "overminuteness" + case papelonne = "papelonne" + case plebification = "plebification" + case pugmiller = "pugmiller" + case recoveror = "recoveror" + case spermatoblastic = "spermatoblastic" + case syllidae = "Syllidae" + case ungyved = "ungyved" + case whirlabout = "whirlabout" + case woodenware = "woodenware" + } + + init(comradely: JSONNull?, diacanthous: JSONNull?, feminineness: JSONNull?, gossamered: JSONNull?, hibernia: JSONNull?, hibiscus: JSONNull?, lepidosauria: JSONNull?, lollingly: JSONNull?, manager: JSONNull?, mechanic: JSONNull?, overminuteness: JSONNull?, papelonne: JSONNull?, plebification: JSONNull?, pugmiller: JSONNull?, recoveror: JSONNull?, spermatoblastic: JSONNull?, syllidae: JSONNull?, ungyved: JSONNull?, whirlabout: JSONNull?, woodenware: JSONNull?) { + self.comradely = comradely + self.diacanthous = diacanthous + self.feminineness = feminineness + self.gossamered = gossamered + self.hibernia = hibernia + self.hibiscus = hibiscus + self.lepidosauria = lepidosauria + self.lollingly = lollingly + self.manager = manager + self.mechanic = mechanic + self.overminuteness = overminuteness + self.papelonne = papelonne + self.plebification = plebification + self.pugmiller = pugmiller + self.recoveror = recoveror + self.spermatoblastic = spermatoblastic + self.syllidae = syllidae + self.ungyved = ungyved + self.whirlabout = whirlabout + self.woodenware = woodenware + } +} + +// MARK: Encrust convenience initializers and mutators + +extension Encrust { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Encrust.self, from: data) + self.init(comradely: me.comradely, diacanthous: me.diacanthous, feminineness: me.feminineness, gossamered: me.gossamered, hibernia: me.hibernia, hibiscus: me.hibiscus, lepidosauria: me.lepidosauria, lollingly: me.lollingly, manager: me.manager, mechanic: me.mechanic, overminuteness: me.overminuteness, papelonne: me.papelonne, plebification: me.plebification, pugmiller: me.pugmiller, recoveror: me.recoveror, spermatoblastic: me.spermatoblastic, syllidae: me.syllidae, ungyved: me.ungyved, whirlabout: me.whirlabout, woodenware: me.woodenware) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + comradely: JSONNull?? = nil, + diacanthous: JSONNull?? = nil, + feminineness: JSONNull?? = nil, + gossamered: JSONNull?? = nil, + hibernia: JSONNull?? = nil, + hibiscus: JSONNull?? = nil, + lepidosauria: JSONNull?? = nil, + lollingly: JSONNull?? = nil, + manager: JSONNull?? = nil, + mechanic: JSONNull?? = nil, + overminuteness: JSONNull?? = nil, + papelonne: JSONNull?? = nil, + plebification: JSONNull?? = nil, + pugmiller: JSONNull?? = nil, + recoveror: JSONNull?? = nil, + spermatoblastic: JSONNull?? = nil, + syllidae: JSONNull?? = nil, + ungyved: JSONNull?? = nil, + whirlabout: JSONNull?? = nil, + woodenware: JSONNull?? = nil + ) -> Encrust { + return Encrust( + comradely: comradely ?? self.comradely, + diacanthous: diacanthous ?? self.diacanthous, + feminineness: feminineness ?? self.feminineness, + gossamered: gossamered ?? self.gossamered, + hibernia: hibernia ?? self.hibernia, + hibiscus: hibiscus ?? self.hibiscus, + lepidosauria: lepidosauria ?? self.lepidosauria, + lollingly: lollingly ?? self.lollingly, + manager: manager ?? self.manager, + mechanic: mechanic ?? self.mechanic, + overminuteness: overminuteness ?? self.overminuteness, + papelonne: papelonne ?? self.papelonne, + plebification: plebification ?? self.plebification, + pugmiller: pugmiller ?? self.pugmiller, + recoveror: recoveror ?? self.recoveror, + spermatoblastic: spermatoblastic ?? self.spermatoblastic, + syllidae: syllidae ?? self.syllidae, + ungyved: ungyved ?? self.ungyved, + whirlabout: whirlabout ?? self.whirlabout, + woodenware: woodenware ?? self.woodenware + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Entomoid: Codable { + case cimeliaClass(CimeliaClass) + case integer(Int) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Entomoid.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Entomoid")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + } + } +} + +enum Epipaleolithic: Codable { + case double(Double) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Epipaleolithic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Epipaleolithic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +enum Expropriable: Codable { + case cimeliaClass(CimeliaClass) + case double(Double) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Expropriable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Expropriable")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum FagginglyElement: Codable { + case double(Double) + case fagginglyClass(FagginglyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(FagginglyClass.self) { + self = .fagginglyClass(x) + return + } + throw DecodingError.typeMismatch(FagginglyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for FagginglyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .fagginglyClass(let x): + try container.encode(x) + } + } +} + +// MARK: - FagginglyClass +final class FagginglyClass: Codable { + let abranchian: JSONNull? + let aculeiform: JSONNull? + let adiaphoristic: JSONNull? + let adoptionism: JSONNull? + let anglic: JSONNull? + let antrotomy: JSONNull? + let coerciveness: JSONNull? + let decorist: JSONNull? + let duckhood: JSONNull? + let heteromeri: JSONNull? + let hypochnose: JSONNull? + let lochage: JSONNull? + let melee: JSONNull? + let nonconformitant: JSONNull? + let poinsettia: JSONNull? + let putatively: JSONNull? + let semivolatile: JSONNull? + let soleas: JSONNull? + let unfastenable: JSONNull? + let unmillinered: JSONNull? + + enum CodingKeys: String, CodingKey { + case abranchian = "abranchian" + case aculeiform = "aculeiform" + case adiaphoristic = "adiaphoristic" + case adoptionism = "adoptionism" + case anglic = "Anglic" + case antrotomy = "antrotomy" + case coerciveness = "coerciveness" + case decorist = "decorist" + case duckhood = "duckhood" + case heteromeri = "Heteromeri" + case hypochnose = "hypochnose" + case lochage = "lochage" + case melee = "melee" + case nonconformitant = "nonconformitant" + case poinsettia = "Poinsettia" + case putatively = "putatively" + case semivolatile = "semivolatile" + case soleas = "soleas" + case unfastenable = "unfastenable" + case unmillinered = "unmillinered" + } + + init(abranchian: JSONNull?, aculeiform: JSONNull?, adiaphoristic: JSONNull?, adoptionism: JSONNull?, anglic: JSONNull?, antrotomy: JSONNull?, coerciveness: JSONNull?, decorist: JSONNull?, duckhood: JSONNull?, heteromeri: JSONNull?, hypochnose: JSONNull?, lochage: JSONNull?, melee: JSONNull?, nonconformitant: JSONNull?, poinsettia: JSONNull?, putatively: JSONNull?, semivolatile: JSONNull?, soleas: JSONNull?, unfastenable: JSONNull?, unmillinered: JSONNull?) { + self.abranchian = abranchian + self.aculeiform = aculeiform + self.adiaphoristic = adiaphoristic + self.adoptionism = adoptionism + self.anglic = anglic + self.antrotomy = antrotomy + self.coerciveness = coerciveness + self.decorist = decorist + self.duckhood = duckhood + self.heteromeri = heteromeri + self.hypochnose = hypochnose + self.lochage = lochage + self.melee = melee + self.nonconformitant = nonconformitant + self.poinsettia = poinsettia + self.putatively = putatively + self.semivolatile = semivolatile + self.soleas = soleas + self.unfastenable = unfastenable + self.unmillinered = unmillinered + } +} + +// MARK: FagginglyClass convenience initializers and mutators + +extension FagginglyClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(FagginglyClass.self, from: data) + self.init(abranchian: me.abranchian, aculeiform: me.aculeiform, adiaphoristic: me.adiaphoristic, adoptionism: me.adoptionism, anglic: me.anglic, antrotomy: me.antrotomy, coerciveness: me.coerciveness, decorist: me.decorist, duckhood: me.duckhood, heteromeri: me.heteromeri, hypochnose: me.hypochnose, lochage: me.lochage, melee: me.melee, nonconformitant: me.nonconformitant, poinsettia: me.poinsettia, putatively: me.putatively, semivolatile: me.semivolatile, soleas: me.soleas, unfastenable: me.unfastenable, unmillinered: me.unmillinered) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + abranchian: JSONNull?? = nil, + aculeiform: JSONNull?? = nil, + adiaphoristic: JSONNull?? = nil, + adoptionism: JSONNull?? = nil, + anglic: JSONNull?? = nil, + antrotomy: JSONNull?? = nil, + coerciveness: JSONNull?? = nil, + decorist: JSONNull?? = nil, + duckhood: JSONNull?? = nil, + heteromeri: JSONNull?? = nil, + hypochnose: JSONNull?? = nil, + lochage: JSONNull?? = nil, + melee: JSONNull?? = nil, + nonconformitant: JSONNull?? = nil, + poinsettia: JSONNull?? = nil, + putatively: JSONNull?? = nil, + semivolatile: JSONNull?? = nil, + soleas: JSONNull?? = nil, + unfastenable: JSONNull?? = nil, + unmillinered: JSONNull?? = nil + ) -> FagginglyClass { + return FagginglyClass( + abranchian: abranchian ?? self.abranchian, + aculeiform: aculeiform ?? self.aculeiform, + adiaphoristic: adiaphoristic ?? self.adiaphoristic, + adoptionism: adoptionism ?? self.adoptionism, + anglic: anglic ?? self.anglic, + antrotomy: antrotomy ?? self.antrotomy, + coerciveness: coerciveness ?? self.coerciveness, + decorist: decorist ?? self.decorist, + duckhood: duckhood ?? self.duckhood, + heteromeri: heteromeri ?? self.heteromeri, + hypochnose: hypochnose ?? self.hypochnose, + lochage: lochage ?? self.lochage, + melee: melee ?? self.melee, + nonconformitant: nonconformitant ?? self.nonconformitant, + poinsettia: poinsettia ?? self.poinsettia, + putatively: putatively ?? self.putatively, + semivolatile: semivolatile ?? self.semivolatile, + soleas: soleas ?? self.soleas, + unfastenable: unfastenable ?? self.unfastenable, + unmillinered: unmillinered ?? self.unmillinered + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum FenkElement: Codable { + case fenkClass(FenkClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(FenkClass.self) { + self = .fenkClass(x) + return + } + throw DecodingError.typeMismatch(FenkElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for FenkElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .fenkClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - FenkClass +final class FenkClass: Codable { + let apoise: JSONNull? + let astronomize: JSONNull? + let cockhorse: JSONNull? + let copular: JSONNull? + let dagomba: JSONNull? + let draffy: JSONNull? + let foreigner: JSONNull? + let guyandot: JSONNull? + let neurogliosis: JSONNull? + let osmious: JSONNull? + let palpitate: JSONNull? + let rebukeable: JSONNull? + let reinwardtia: JSONNull? + let reservatory: JSONNull? + let scalt: JSONNull? + let scripturalize: JSONNull? + let tintometer: JSONNull? + let tritoness: JSONNull? + let undergrade: JSONNull? + let undermountain: JSONNull? + + enum CodingKeys: String, CodingKey { + case apoise = "apoise" + case astronomize = "astronomize" + case cockhorse = "cockhorse" + case copular = "copular" + case dagomba = "Dagomba" + case draffy = "draffy" + case foreigner = "foreigner" + case guyandot = "Guyandot" + case neurogliosis = "neurogliosis" + case osmious = "osmious" + case palpitate = "palpitate" + case rebukeable = "rebukeable" + case reinwardtia = "Reinwardtia" + case reservatory = "reservatory" + case scalt = "scalt" + case scripturalize = "scripturalize" + case tintometer = "tintometer" + case tritoness = "Tritoness" + case undergrade = "undergrade" + case undermountain = "undermountain" + } + + init(apoise: JSONNull?, astronomize: JSONNull?, cockhorse: JSONNull?, copular: JSONNull?, dagomba: JSONNull?, draffy: JSONNull?, foreigner: JSONNull?, guyandot: JSONNull?, neurogliosis: JSONNull?, osmious: JSONNull?, palpitate: JSONNull?, rebukeable: JSONNull?, reinwardtia: JSONNull?, reservatory: JSONNull?, scalt: JSONNull?, scripturalize: JSONNull?, tintometer: JSONNull?, tritoness: JSONNull?, undergrade: JSONNull?, undermountain: JSONNull?) { + self.apoise = apoise + self.astronomize = astronomize + self.cockhorse = cockhorse + self.copular = copular + self.dagomba = dagomba + self.draffy = draffy + self.foreigner = foreigner + self.guyandot = guyandot + self.neurogliosis = neurogliosis + self.osmious = osmious + self.palpitate = palpitate + self.rebukeable = rebukeable + self.reinwardtia = reinwardtia + self.reservatory = reservatory + self.scalt = scalt + self.scripturalize = scripturalize + self.tintometer = tintometer + self.tritoness = tritoness + self.undergrade = undergrade + self.undermountain = undermountain + } +} + +// MARK: FenkClass convenience initializers and mutators + +extension FenkClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(FenkClass.self, from: data) + self.init(apoise: me.apoise, astronomize: me.astronomize, cockhorse: me.cockhorse, copular: me.copular, dagomba: me.dagomba, draffy: me.draffy, foreigner: me.foreigner, guyandot: me.guyandot, neurogliosis: me.neurogliosis, osmious: me.osmious, palpitate: me.palpitate, rebukeable: me.rebukeable, reinwardtia: me.reinwardtia, reservatory: me.reservatory, scalt: me.scalt, scripturalize: me.scripturalize, tintometer: me.tintometer, tritoness: me.tritoness, undergrade: me.undergrade, undermountain: me.undermountain) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + apoise: JSONNull?? = nil, + astronomize: JSONNull?? = nil, + cockhorse: JSONNull?? = nil, + copular: JSONNull?? = nil, + dagomba: JSONNull?? = nil, + draffy: JSONNull?? = nil, + foreigner: JSONNull?? = nil, + guyandot: JSONNull?? = nil, + neurogliosis: JSONNull?? = nil, + osmious: JSONNull?? = nil, + palpitate: JSONNull?? = nil, + rebukeable: JSONNull?? = nil, + reinwardtia: JSONNull?? = nil, + reservatory: JSONNull?? = nil, + scalt: JSONNull?? = nil, + scripturalize: JSONNull?? = nil, + tintometer: JSONNull?? = nil, + tritoness: JSONNull?? = nil, + undergrade: JSONNull?? = nil, + undermountain: JSONNull?? = nil + ) -> FenkClass { + return FenkClass( + apoise: apoise ?? self.apoise, + astronomize: astronomize ?? self.astronomize, + cockhorse: cockhorse ?? self.cockhorse, + copular: copular ?? self.copular, + dagomba: dagomba ?? self.dagomba, + draffy: draffy ?? self.draffy, + foreigner: foreigner ?? self.foreigner, + guyandot: guyandot ?? self.guyandot, + neurogliosis: neurogliosis ?? self.neurogliosis, + osmious: osmious ?? self.osmious, + palpitate: palpitate ?? self.palpitate, + rebukeable: rebukeable ?? self.rebukeable, + reinwardtia: reinwardtia ?? self.reinwardtia, + reservatory: reservatory ?? self.reservatory, + scalt: scalt ?? self.scalt, + scripturalize: scripturalize ?? self.scripturalize, + tintometer: tintometer ?? self.tintometer, + tritoness: tritoness ?? self.tritoness, + undergrade: undergrade ?? self.undergrade, + undermountain: undermountain ?? self.undermountain + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum FlagmakingElement: Codable { + case bool(Bool) + case double(Double) + case flagmakingClass(FlagmakingClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(FlagmakingClass.self) { + self = .flagmakingClass(x) + return + } + throw DecodingError.typeMismatch(FlagmakingElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for FlagmakingElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .flagmakingClass(let x): + try container.encode(x) + } + } +} + +// MARK: - FlagmakingClass +final class FlagmakingClass: Codable { + let albarco: JSONNull? + let bunodonta: JSONNull? + let hornify: JSONNull? + let hydrocorisae: JSONNull? + let hypoglossus: JSONNull? + let inexpiably: JSONNull? + let ingratitude: JSONNull? + let ladyfly: JSONNull? + let medicament: JSONNull? + let monogrammatic: JSONNull? + let nobbut: JSONNull? + let notacanthidae: JSONNull? + let polyplacophore: JSONNull? + let proexercise: JSONNull? + let protoplast: JSONNull? + let puzzling: JSONNull? + let splanchnoskeleton: JSONNull? + let unloveliness: JSONNull? + let unquarantined: JSONNull? + let unrenounceable: JSONNull? + + enum CodingKeys: String, CodingKey { + case albarco = "albarco" + case bunodonta = "Bunodonta" + case hornify = "hornify" + case hydrocorisae = "Hydrocorisae" + case hypoglossus = "hypoglossus" + case inexpiably = "inexpiably" + case ingratitude = "ingratitude" + case ladyfly = "ladyfly" + case medicament = "medicament" + case monogrammatic = "monogrammatic" + case nobbut = "nobbut" + case notacanthidae = "Notacanthidae" + case polyplacophore = "polyplacophore" + case proexercise = "proexercise" + case protoplast = "protoplast" + case puzzling = "puzzling" + case splanchnoskeleton = "splanchnoskeleton" + case unloveliness = "unloveliness" + case unquarantined = "unquarantined" + case unrenounceable = "unrenounceable" + } + + init(albarco: JSONNull?, bunodonta: JSONNull?, hornify: JSONNull?, hydrocorisae: JSONNull?, hypoglossus: JSONNull?, inexpiably: JSONNull?, ingratitude: JSONNull?, ladyfly: JSONNull?, medicament: JSONNull?, monogrammatic: JSONNull?, nobbut: JSONNull?, notacanthidae: JSONNull?, polyplacophore: JSONNull?, proexercise: JSONNull?, protoplast: JSONNull?, puzzling: JSONNull?, splanchnoskeleton: JSONNull?, unloveliness: JSONNull?, unquarantined: JSONNull?, unrenounceable: JSONNull?) { + self.albarco = albarco + self.bunodonta = bunodonta + self.hornify = hornify + self.hydrocorisae = hydrocorisae + self.hypoglossus = hypoglossus + self.inexpiably = inexpiably + self.ingratitude = ingratitude + self.ladyfly = ladyfly + self.medicament = medicament + self.monogrammatic = monogrammatic + self.nobbut = nobbut + self.notacanthidae = notacanthidae + self.polyplacophore = polyplacophore + self.proexercise = proexercise + self.protoplast = protoplast + self.puzzling = puzzling + self.splanchnoskeleton = splanchnoskeleton + self.unloveliness = unloveliness + self.unquarantined = unquarantined + self.unrenounceable = unrenounceable + } +} + +// MARK: FlagmakingClass convenience initializers and mutators + +extension FlagmakingClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(FlagmakingClass.self, from: data) + self.init(albarco: me.albarco, bunodonta: me.bunodonta, hornify: me.hornify, hydrocorisae: me.hydrocorisae, hypoglossus: me.hypoglossus, inexpiably: me.inexpiably, ingratitude: me.ingratitude, ladyfly: me.ladyfly, medicament: me.medicament, monogrammatic: me.monogrammatic, nobbut: me.nobbut, notacanthidae: me.notacanthidae, polyplacophore: me.polyplacophore, proexercise: me.proexercise, protoplast: me.protoplast, puzzling: me.puzzling, splanchnoskeleton: me.splanchnoskeleton, unloveliness: me.unloveliness, unquarantined: me.unquarantined, unrenounceable: me.unrenounceable) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + albarco: JSONNull?? = nil, + bunodonta: JSONNull?? = nil, + hornify: JSONNull?? = nil, + hydrocorisae: JSONNull?? = nil, + hypoglossus: JSONNull?? = nil, + inexpiably: JSONNull?? = nil, + ingratitude: JSONNull?? = nil, + ladyfly: JSONNull?? = nil, + medicament: JSONNull?? = nil, + monogrammatic: JSONNull?? = nil, + nobbut: JSONNull?? = nil, + notacanthidae: JSONNull?? = nil, + polyplacophore: JSONNull?? = nil, + proexercise: JSONNull?? = nil, + protoplast: JSONNull?? = nil, + puzzling: JSONNull?? = nil, + splanchnoskeleton: JSONNull?? = nil, + unloveliness: JSONNull?? = nil, + unquarantined: JSONNull?? = nil, + unrenounceable: JSONNull?? = nil + ) -> FlagmakingClass { + return FlagmakingClass( + albarco: albarco ?? self.albarco, + bunodonta: bunodonta ?? self.bunodonta, + hornify: hornify ?? self.hornify, + hydrocorisae: hydrocorisae ?? self.hydrocorisae, + hypoglossus: hypoglossus ?? self.hypoglossus, + inexpiably: inexpiably ?? self.inexpiably, + ingratitude: ingratitude ?? self.ingratitude, + ladyfly: ladyfly ?? self.ladyfly, + medicament: medicament ?? self.medicament, + monogrammatic: monogrammatic ?? self.monogrammatic, + nobbut: nobbut ?? self.nobbut, + notacanthidae: notacanthidae ?? self.notacanthidae, + polyplacophore: polyplacophore ?? self.polyplacophore, + proexercise: proexercise ?? self.proexercise, + protoplast: protoplast ?? self.protoplast, + puzzling: puzzling ?? self.puzzling, + splanchnoskeleton: splanchnoskeleton ?? self.splanchnoskeleton, + unloveliness: unloveliness ?? self.unloveliness, + unquarantined: unquarantined ?? self.unquarantined, + unrenounceable: unrenounceable ?? self.unrenounceable + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Fluorometer: Codable { + case integer(Int) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Fluorometer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Fluorometer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Fuzzy: Codable { + case integer(Int) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Fuzzy.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Fuzzy")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +enum Gardenward: Codable { + case bool(Bool) + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Gardenward.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Gardenward")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Generalissimo: Codable { + case bool(Bool) + case integerMap([String: Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Generalissimo.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Generalissimo")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Hemicrystalline: Codable { + case cimeliaClass(CimeliaClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Hemicrystalline.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hemicrystalline")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum HemocoeleElement: Codable { + case hemocoeleClass(HemocoeleClass) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(HemocoeleClass.self) { + self = .hemocoeleClass(x) + return + } + throw DecodingError.typeMismatch(HemocoeleElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for HemocoeleElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .hemocoeleClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +// MARK: - HemocoeleClass +final class HemocoeleClass: Codable { + let acrogamy: JSONNull? + let amelification: JSONNull? + let autobiographic: JSONNull? + let berat: JSONNull? + let catharticalness: Double? + let chirotherium: Int? + let disdiapason: String? + let disproportionably: JSONNull? + let erythrite: JSONNull? + let graphic: JSONNull? + let hepatological: JSONNull? + let homocerc: Bool? + let incommensurably: JSONNull? + let misaffirm: JSONNull? + let nonbookish: JSONNull? + let pocketbook: JSONNull? + let sclerometric: JSONNull? + let stambouline: JSONNull? + let stickpin: JSONNull? + let tubulure: JSONNull? + let undelated: JSONNull? + let unsalt: JSONNull? + let untutelar: JSONNull? + let vagrant: JSONNull? + let walt: JSONNull? + + enum CodingKeys: String, CodingKey { + case acrogamy = "acrogamy" + case amelification = "amelification" + case autobiographic = "autobiographic" + case berat = "berat" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case disproportionably = "disproportionably" + case erythrite = "erythrite" + case graphic = "graphic" + case hepatological = "hepatological" + case homocerc = "homocerc" + case incommensurably = "incommensurably" + case misaffirm = "misaffirm" + case nonbookish = "nonbookish" + case pocketbook = "pocketbook" + case sclerometric = "sclerometric" + case stambouline = "stambouline" + case stickpin = "stickpin" + case tubulure = "tubulure" + case undelated = "undelated" + case unsalt = "unsalt" + case untutelar = "untutelar" + case vagrant = "vagrant" + case walt = "Walt" + } + + init(acrogamy: JSONNull?, amelification: JSONNull?, autobiographic: JSONNull?, berat: JSONNull?, catharticalness: Double?, chirotherium: Int?, disdiapason: String?, disproportionably: JSONNull?, erythrite: JSONNull?, graphic: JSONNull?, hepatological: JSONNull?, homocerc: Bool?, incommensurably: JSONNull?, misaffirm: JSONNull?, nonbookish: JSONNull?, pocketbook: JSONNull?, sclerometric: JSONNull?, stambouline: JSONNull?, stickpin: JSONNull?, tubulure: JSONNull?, undelated: JSONNull?, unsalt: JSONNull?, untutelar: JSONNull?, vagrant: JSONNull?, walt: JSONNull?) { + self.acrogamy = acrogamy + self.amelification = amelification + self.autobiographic = autobiographic + self.berat = berat + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.disproportionably = disproportionably + self.erythrite = erythrite + self.graphic = graphic + self.hepatological = hepatological + self.homocerc = homocerc + self.incommensurably = incommensurably + self.misaffirm = misaffirm + self.nonbookish = nonbookish + self.pocketbook = pocketbook + self.sclerometric = sclerometric + self.stambouline = stambouline + self.stickpin = stickpin + self.tubulure = tubulure + self.undelated = undelated + self.unsalt = unsalt + self.untutelar = untutelar + self.vagrant = vagrant + self.walt = walt + } +} + +// MARK: HemocoeleClass convenience initializers and mutators + +extension HemocoeleClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(HemocoeleClass.self, from: data) + self.init(acrogamy: me.acrogamy, amelification: me.amelification, autobiographic: me.autobiographic, berat: me.berat, catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, disproportionably: me.disproportionably, erythrite: me.erythrite, graphic: me.graphic, hepatological: me.hepatological, homocerc: me.homocerc, incommensurably: me.incommensurably, misaffirm: me.misaffirm, nonbookish: me.nonbookish, pocketbook: me.pocketbook, sclerometric: me.sclerometric, stambouline: me.stambouline, stickpin: me.stickpin, tubulure: me.tubulure, undelated: me.undelated, unsalt: me.unsalt, untutelar: me.untutelar, vagrant: me.vagrant, walt: me.walt) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acrogamy: JSONNull?? = nil, + amelification: JSONNull?? = nil, + autobiographic: JSONNull?? = nil, + berat: JSONNull?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + disproportionably: JSONNull?? = nil, + erythrite: JSONNull?? = nil, + graphic: JSONNull?? = nil, + hepatological: JSONNull?? = nil, + homocerc: Bool?? = nil, + incommensurably: JSONNull?? = nil, + misaffirm: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + pocketbook: JSONNull?? = nil, + sclerometric: JSONNull?? = nil, + stambouline: JSONNull?? = nil, + stickpin: JSONNull?? = nil, + tubulure: JSONNull?? = nil, + undelated: JSONNull?? = nil, + unsalt: JSONNull?? = nil, + untutelar: JSONNull?? = nil, + vagrant: JSONNull?? = nil, + walt: JSONNull?? = nil + ) -> HemocoeleClass { + return HemocoeleClass( + acrogamy: acrogamy ?? self.acrogamy, + amelification: amelification ?? self.amelification, + autobiographic: autobiographic ?? self.autobiographic, + berat: berat ?? self.berat, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + disproportionably: disproportionably ?? self.disproportionably, + erythrite: erythrite ?? self.erythrite, + graphic: graphic ?? self.graphic, + hepatological: hepatological ?? self.hepatological, + homocerc: homocerc ?? self.homocerc, + incommensurably: incommensurably ?? self.incommensurably, + misaffirm: misaffirm ?? self.misaffirm, + nonbookish: nonbookish ?? self.nonbookish, + pocketbook: pocketbook ?? self.pocketbook, + sclerometric: sclerometric ?? self.sclerometric, + stambouline: stambouline ?? self.stambouline, + stickpin: stickpin ?? self.stickpin, + tubulure: tubulure ?? self.tubulure, + undelated: undelated ?? self.undelated, + unsalt: unsalt ?? self.unsalt, + untutelar: untutelar ?? self.untutelar, + vagrant: vagrant ?? self.vagrant, + walt: walt ?? self.walt + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Hoister: Codable { + case cimeliaClass(CimeliaClass) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Hoister.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hoister")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Hyperpiesi: Codable { + case cimeliaClass(CimeliaClass) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Hyperpiesi.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hyperpiesi")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Hyppish: Codable { + case bool(Bool) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Hyppish.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hyppish")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Idealizer: Codable { + case cimeliaClass(CimeliaClass) + case integer(Int) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Idealizer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Idealizer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Incrustator: Codable { + case integer(Int) + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Incrustator.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Incrustator")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Intentiveness: Codable { + case cimeliaClass(CimeliaClass) + case double(Double) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Intentiveness.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Intentiveness")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - Interacinar +final class Interacinar: Codable { + let assapan: Double + let benefactorship: Bool + let triseriatim: String + let tubbing: Int + let untrimmed: JSONNull? + + enum CodingKeys: String, CodingKey { + case assapan = "assapan" + case benefactorship = "benefactorship" + case triseriatim = "triseriatim" + case tubbing = "tubbing" + case untrimmed = "untrimmed" + } + + init(assapan: Double, benefactorship: Bool, triseriatim: String, tubbing: Int, untrimmed: JSONNull?) { + self.assapan = assapan + self.benefactorship = benefactorship + self.triseriatim = triseriatim + self.tubbing = tubbing + self.untrimmed = untrimmed + } +} + +// MARK: Interacinar convenience initializers and mutators + +extension Interacinar { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Interacinar.self, from: data) + self.init(assapan: me.assapan, benefactorship: me.benefactorship, triseriatim: me.triseriatim, tubbing: me.tubbing, untrimmed: me.untrimmed) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + assapan: Double? = nil, + benefactorship: Bool? = nil, + triseriatim: String? = nil, + tubbing: Int? = nil, + untrimmed: JSONNull?? = nil + ) -> Interacinar { + return Interacinar( + assapan: assapan ?? self.assapan, + benefactorship: benefactorship ?? self.benefactorship, + triseriatim: triseriatim ?? self.triseriatim, + tubbing: tubbing ?? self.tubbing, + untrimmed: untrimmed ?? self.untrimmed + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Jacutinga: Codable { + case integerArray([Int]) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Jacutinga.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Jacutinga")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +// MARK: - Helper functions for creating encoders and decoders + +func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder +} + +func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// MARK: - Encode/decode helpers + +final class JSONNull: Codable, Hashable { + + public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool { + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(0) + } + + public init() {} + + public required init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if !container.decodeNil() { + throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull")) + } + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + try container.encodeNil() + } +} diff --git a/head/swift/test/inputs/json/priority/combinations1.json/protocol-hashable--739b516c7897/quicktype.swift b/head/swift/test/inputs/json/priority/combinations1.json/protocol-hashable--739b516c7897/quicktype.swift new file mode 100644 index 0000000..740138a --- /dev/null +++ b/head/swift/test/inputs/json/priority/combinations1.json/protocol-hashable--739b516c7897/quicktype.swift @@ -0,0 +1,2922 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +import Foundation + +// MARK: - TopLevel +struct TopLevel: Codable, Hashable { + let centrodesmose: String + let cerograph: [CerographElement] + let chemotherapeutics: [ChemotherapeuticElement] + let cimelia: [CimeliaElement] + let citrated: Int + let clinodome: [Clinodome] + let coadjust: [CoadjustElement] + let consilience: [Consilience] + let constructor: [Constructor] + let continuative: [Continuative] + let credulity: [CredulityElement] + let creviced: [Creviced] + let cubiculum: [[Int?]] + let deruralize: [DeruralizeElement] + let diaereses: [DiaereseElement] + let dissolution: [[JSONNull?]?] + let downstroke: [Downstroke] + let electrotautomerism: [Double?] + let eleutheromania: [Eleutheromania] + let encrust: Encrust + let entomoid: [Entomoid] + let epipaleolithic: [Epipaleolithic] + let expropriable: [Expropriable] + let faggingly: [FagginglyElement] + let fenks: [FenkElement] + let flagmaking: [FlagmakingElement] + let fluorometer: [Fluorometer] + let fulsome: [Int?] + let fuzzy: [Fuzzy] + let gardenwards: [Gardenward] + let generalissimo: [Generalissimo] + let habeas: [[String: Int]?] + let hemicrystalline: [Hemicrystalline] + let hemocoele: [HemocoeleElement] + let hoister: [Hoister] + let hyperpiesis: [Hyperpiesi] + let hyppish: [Hyppish] + let idealizer: [Idealizer] + let incrustator: [Incrustator] + let intentiveness: [Intentiveness] + let interacinar: Interacinar + let intercorrelation: [[Int]?] + let jacutinga: [Jacutinga] + + enum CodingKeys: String, CodingKey { + case centrodesmose = "centrodesmose" + case cerograph = "cerograph" + case chemotherapeutics = "chemotherapeutics" + case cimelia = "cimelia" + case citrated = "citrated" + case clinodome = "clinodome" + case coadjust = "coadjust" + case consilience = "consilience" + case constructor = "constructor" + case continuative = "continuative" + case credulity = "credulity" + case creviced = "creviced" + case cubiculum = "cubiculum" + case deruralize = "deruralize" + case diaereses = "diaereses" + case dissolution = "dissolution" + case downstroke = "downstroke" + case electrotautomerism = "electrotautomerism" + case eleutheromania = "eleutheromania" + case encrust = "encrust" + case entomoid = "entomoid" + case epipaleolithic = "epipaleolithic" + case expropriable = "expropriable" + case faggingly = "faggingly" + case fenks = "fenks" + case flagmaking = "flagmaking" + case fluorometer = "fluorometer" + case fulsome = "fulsome" + case fuzzy = "fuzzy" + case gardenwards = "gardenwards" + case generalissimo = "generalissimo" + case habeas = "habeas" + case hemicrystalline = "hemicrystalline" + case hemocoele = "hemocoele" + case hoister = "hoister" + case hyperpiesis = "hyperpiesis" + case hyppish = "hyppish" + case idealizer = "idealizer" + case incrustator = "incrustator" + case intentiveness = "intentiveness" + case interacinar = "interacinar" + case intercorrelation = "intercorrelation" + case jacutinga = "jacutinga" + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + init(data: Data) throws { + self = try newJSONDecoder().decode(TopLevel.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + centrodesmose: String? = nil, + cerograph: [CerographElement]? = nil, + chemotherapeutics: [ChemotherapeuticElement]? = nil, + cimelia: [CimeliaElement]? = nil, + citrated: Int? = nil, + clinodome: [Clinodome]? = nil, + coadjust: [CoadjustElement]? = nil, + consilience: [Consilience]? = nil, + constructor: [Constructor]? = nil, + continuative: [Continuative]? = nil, + credulity: [CredulityElement]? = nil, + creviced: [Creviced]? = nil, + cubiculum: [[Int?]]? = nil, + deruralize: [DeruralizeElement]? = nil, + diaereses: [DiaereseElement]? = nil, + dissolution: [[JSONNull?]?]? = nil, + downstroke: [Downstroke]? = nil, + electrotautomerism: [Double?]? = nil, + eleutheromania: [Eleutheromania]? = nil, + encrust: Encrust? = nil, + entomoid: [Entomoid]? = nil, + epipaleolithic: [Epipaleolithic]? = nil, + expropriable: [Expropriable]? = nil, + faggingly: [FagginglyElement]? = nil, + fenks: [FenkElement]? = nil, + flagmaking: [FlagmakingElement]? = nil, + fluorometer: [Fluorometer]? = nil, + fulsome: [Int?]? = nil, + fuzzy: [Fuzzy]? = nil, + gardenwards: [Gardenward]? = nil, + generalissimo: [Generalissimo]? = nil, + habeas: [[String: Int]?]? = nil, + hemicrystalline: [Hemicrystalline]? = nil, + hemocoele: [HemocoeleElement]? = nil, + hoister: [Hoister]? = nil, + hyperpiesis: [Hyperpiesi]? = nil, + hyppish: [Hyppish]? = nil, + idealizer: [Idealizer]? = nil, + incrustator: [Incrustator]? = nil, + intentiveness: [Intentiveness]? = nil, + interacinar: Interacinar? = nil, + intercorrelation: [[Int]?]? = nil, + jacutinga: [Jacutinga]? = nil + ) -> TopLevel { + return TopLevel( + centrodesmose: centrodesmose ?? self.centrodesmose, + cerograph: cerograph ?? self.cerograph, + chemotherapeutics: chemotherapeutics ?? self.chemotherapeutics, + cimelia: cimelia ?? self.cimelia, + citrated: citrated ?? self.citrated, + clinodome: clinodome ?? self.clinodome, + coadjust: coadjust ?? self.coadjust, + consilience: consilience ?? self.consilience, + constructor: constructor ?? self.constructor, + continuative: continuative ?? self.continuative, + credulity: credulity ?? self.credulity, + creviced: creviced ?? self.creviced, + cubiculum: cubiculum ?? self.cubiculum, + deruralize: deruralize ?? self.deruralize, + diaereses: diaereses ?? self.diaereses, + dissolution: dissolution ?? self.dissolution, + downstroke: downstroke ?? self.downstroke, + electrotautomerism: electrotautomerism ?? self.electrotautomerism, + eleutheromania: eleutheromania ?? self.eleutheromania, + encrust: encrust ?? self.encrust, + entomoid: entomoid ?? self.entomoid, + epipaleolithic: epipaleolithic ?? self.epipaleolithic, + expropriable: expropriable ?? self.expropriable, + faggingly: faggingly ?? self.faggingly, + fenks: fenks ?? self.fenks, + flagmaking: flagmaking ?? self.flagmaking, + fluorometer: fluorometer ?? self.fluorometer, + fulsome: fulsome ?? self.fulsome, + fuzzy: fuzzy ?? self.fuzzy, + gardenwards: gardenwards ?? self.gardenwards, + generalissimo: generalissimo ?? self.generalissimo, + habeas: habeas ?? self.habeas, + hemicrystalline: hemicrystalline ?? self.hemicrystalline, + hemocoele: hemocoele ?? self.hemocoele, + hoister: hoister ?? self.hoister, + hyperpiesis: hyperpiesis ?? self.hyperpiesis, + hyppish: hyppish ?? self.hyppish, + idealizer: idealizer ?? self.idealizer, + incrustator: incrustator ?? self.incrustator, + intentiveness: intentiveness ?? self.intentiveness, + interacinar: interacinar ?? self.interacinar, + intercorrelation: intercorrelation ?? self.intercorrelation, + jacutinga: jacutinga ?? self.jacutinga + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum CerographElement: Codable, Hashable { + case cerographClass(CerographClass) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CerographClass.self) { + self = .cerographClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(CerographElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CerographElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cerographClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - CerographClass +struct CerographClass: Codable, Hashable { + let apotropaion: JSONNull? + let casuary: JSONNull? + let creaker: JSONNull? + let disqualification: JSONNull? + let imperatorious: JSONNull? + let impermeabilize: JSONNull? + let metastoma: JSONNull? + let noctidiurnal: JSONNull? + let nonreserve: JSONNull? + let ophthalmotonometry: JSONNull? + let pailful: JSONNull? + let pigfish: JSONNull? + let pongee: JSONNull? + let prosodical: JSONNull? + let scrofuloderm: JSONNull? + let storekeeping: JSONNull? + let therologist: JSONNull? + let tolowa: JSONNull? + let tradeful: JSONNull? + let unriveting: JSONNull? + + enum CodingKeys: String, CodingKey { + case apotropaion = "apotropaion" + case casuary = "casuary" + case creaker = "creaker" + case disqualification = "disqualification" + case imperatorious = "imperatorious" + case impermeabilize = "impermeabilize" + case metastoma = "metastoma" + case noctidiurnal = "noctidiurnal" + case nonreserve = "nonreserve" + case ophthalmotonometry = "ophthalmotonometry" + case pailful = "pailful" + case pigfish = "pigfish" + case pongee = "pongee" + case prosodical = "prosodical" + case scrofuloderm = "scrofuloderm" + case storekeeping = "storekeeping" + case therologist = "therologist" + case tolowa = "Tolowa" + case tradeful = "tradeful" + case unriveting = "unriveting" + } +} + +// MARK: CerographClass convenience initializers and mutators + +extension CerographClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(CerographClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + apotropaion: JSONNull?? = nil, + casuary: JSONNull?? = nil, + creaker: JSONNull?? = nil, + disqualification: JSONNull?? = nil, + imperatorious: JSONNull?? = nil, + impermeabilize: JSONNull?? = nil, + metastoma: JSONNull?? = nil, + noctidiurnal: JSONNull?? = nil, + nonreserve: JSONNull?? = nil, + ophthalmotonometry: JSONNull?? = nil, + pailful: JSONNull?? = nil, + pigfish: JSONNull?? = nil, + pongee: JSONNull?? = nil, + prosodical: JSONNull?? = nil, + scrofuloderm: JSONNull?? = nil, + storekeeping: JSONNull?? = nil, + therologist: JSONNull?? = nil, + tolowa: JSONNull?? = nil, + tradeful: JSONNull?? = nil, + unriveting: JSONNull?? = nil + ) -> CerographClass { + return CerographClass( + apotropaion: apotropaion ?? self.apotropaion, + casuary: casuary ?? self.casuary, + creaker: creaker ?? self.creaker, + disqualification: disqualification ?? self.disqualification, + imperatorious: imperatorious ?? self.imperatorious, + impermeabilize: impermeabilize ?? self.impermeabilize, + metastoma: metastoma ?? self.metastoma, + noctidiurnal: noctidiurnal ?? self.noctidiurnal, + nonreserve: nonreserve ?? self.nonreserve, + ophthalmotonometry: ophthalmotonometry ?? self.ophthalmotonometry, + pailful: pailful ?? self.pailful, + pigfish: pigfish ?? self.pigfish, + pongee: pongee ?? self.pongee, + prosodical: prosodical ?? self.prosodical, + scrofuloderm: scrofuloderm ?? self.scrofuloderm, + storekeeping: storekeeping ?? self.storekeeping, + therologist: therologist ?? self.therologist, + tolowa: tolowa ?? self.tolowa, + tradeful: tradeful ?? self.tradeful, + unriveting: unriveting ?? self.unriveting + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum ChemotherapeuticElement: Codable, Hashable { + case chemotherapeuticClass(ChemotherapeuticClass) + case integer(Int) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(ChemotherapeuticClass.self) { + self = .chemotherapeuticClass(x) + return + } + throw DecodingError.typeMismatch(ChemotherapeuticElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for ChemotherapeuticElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .chemotherapeuticClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - ChemotherapeuticClass +struct ChemotherapeuticClass: Codable, Hashable { + let angioneurotic: JSONNull? + let availment: JSONNull? + let bladelet: JSONNull? + let catharticalness: Double? + let caulis: JSONNull? + let chalcus: JSONNull? + let chirotherium: Int? + let disdiapason: String? + let enteradenological: JSONNull? + let homocerc: Bool? + let imporosity: JSONNull? + let insistently: JSONNull? + let intraparietal: JSONNull? + let ivied: JSONNull? + let maureen: JSONNull? + let nonbookish: JSONNull? + let nostochine: JSONNull? + let nutcracker: JSONNull? + let ofttimes: JSONNull? + let phenocryst: JSONNull? + let precoincident: JSONNull? + let ramiferous: JSONNull? + let stagmometer: JSONNull? + let tetherball: JSONNull? + let unshy: JSONNull? + + enum CodingKeys: String, CodingKey { + case angioneurotic = "angioneurotic" + case availment = "availment" + case bladelet = "bladelet" + case catharticalness = "catharticalness" + case caulis = "caulis" + case chalcus = "chalcus" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case enteradenological = "enteradenological" + case homocerc = "homocerc" + case imporosity = "imporosity" + case insistently = "insistently" + case intraparietal = "intraparietal" + case ivied = "ivied" + case maureen = "Maureen" + case nonbookish = "nonbookish" + case nostochine = "nostochine" + case nutcracker = "nutcracker" + case ofttimes = "ofttimes" + case phenocryst = "phenocryst" + case precoincident = "precoincident" + case ramiferous = "ramiferous" + case stagmometer = "stagmometer" + case tetherball = "tetherball" + case unshy = "unshy" + } +} + +// MARK: ChemotherapeuticClass convenience initializers and mutators + +extension ChemotherapeuticClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(ChemotherapeuticClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + angioneurotic: JSONNull?? = nil, + availment: JSONNull?? = nil, + bladelet: JSONNull?? = nil, + catharticalness: Double?? = nil, + caulis: JSONNull?? = nil, + chalcus: JSONNull?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + enteradenological: JSONNull?? = nil, + homocerc: Bool?? = nil, + imporosity: JSONNull?? = nil, + insistently: JSONNull?? = nil, + intraparietal: JSONNull?? = nil, + ivied: JSONNull?? = nil, + maureen: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + nostochine: JSONNull?? = nil, + nutcracker: JSONNull?? = nil, + ofttimes: JSONNull?? = nil, + phenocryst: JSONNull?? = nil, + precoincident: JSONNull?? = nil, + ramiferous: JSONNull?? = nil, + stagmometer: JSONNull?? = nil, + tetherball: JSONNull?? = nil, + unshy: JSONNull?? = nil + ) -> ChemotherapeuticClass { + return ChemotherapeuticClass( + angioneurotic: angioneurotic ?? self.angioneurotic, + availment: availment ?? self.availment, + bladelet: bladelet ?? self.bladelet, + catharticalness: catharticalness ?? self.catharticalness, + caulis: caulis ?? self.caulis, + chalcus: chalcus ?? self.chalcus, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + enteradenological: enteradenological ?? self.enteradenological, + homocerc: homocerc ?? self.homocerc, + imporosity: imporosity ?? self.imporosity, + insistently: insistently ?? self.insistently, + intraparietal: intraparietal ?? self.intraparietal, + ivied: ivied ?? self.ivied, + maureen: maureen ?? self.maureen, + nonbookish: nonbookish ?? self.nonbookish, + nostochine: nostochine ?? self.nostochine, + nutcracker: nutcracker ?? self.nutcracker, + ofttimes: ofttimes ?? self.ofttimes, + phenocryst: phenocryst ?? self.phenocryst, + precoincident: precoincident ?? self.precoincident, + ramiferous: ramiferous ?? self.ramiferous, + stagmometer: stagmometer ?? self.stagmometer, + tetherball: tetherball ?? self.tetherball, + unshy: unshy ?? self.unshy + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum CimeliaElement: Codable, Hashable { + case cimeliaClass(CimeliaClass) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(CimeliaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CimeliaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - CimeliaClass +struct CimeliaClass: Codable, Hashable { + let catharticalness: Double + let chirotherium: Int + let disdiapason: String + let homocerc: Bool + let nonbookish: JSONNull? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case homocerc = "homocerc" + case nonbookish = "nonbookish" + } +} + +// MARK: CimeliaClass convenience initializers and mutators + +extension CimeliaClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(CimeliaClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double? = nil, + chirotherium: Int? = nil, + disdiapason: String? = nil, + homocerc: Bool? = nil, + nonbookish: JSONNull?? = nil + ) -> CimeliaClass { + return CimeliaClass( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + homocerc: homocerc ?? self.homocerc, + nonbookish: nonbookish ?? self.nonbookish + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Clinodome: Codable, Hashable { + case double(Double) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Clinodome.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Clinodome")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum CoadjustElement: Codable, Hashable { + case coadjustClass(CoadjustClass) + case double(Double) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(CoadjustClass.self) { + self = .coadjustClass(x) + return + } + throw DecodingError.typeMismatch(CoadjustElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CoadjustElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .coadjustClass(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - CoadjustClass +struct CoadjustClass: Codable, Hashable { + let amidosulphonal: JSONNull? + let benny: JSONNull? + let catharticalness: Double? + let chirotherium: Int? + let disdiapason: String? + let ensnare: JSONNull? + let homocerc: Bool? + let hybridizer: JSONNull? + let leastwise: JSONNull? + let lof: JSONNull? + let monkhood: JSONNull? + let netherlandish: JSONNull? + let nonbookish: JSONNull? + let peonism: JSONNull? + let phonelescope: JSONNull? + let porphyrogeniture: JSONNull? + let preindemnify: JSONNull? + let rosal: JSONNull? + let scalenous: JSONNull? + let scopine: JSONNull? + let sedaceae: JSONNull? + let suberinize: JSONNull? + let symbiot: JSONNull? + let tablefellow: JSONNull? + let unchargeable: JSONNull? + + enum CodingKeys: String, CodingKey { + case amidosulphonal = "amidosulphonal" + case benny = "Benny" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case ensnare = "ensnare" + case homocerc = "homocerc" + case hybridizer = "hybridizer" + case leastwise = "leastwise" + case lof = "lof" + case monkhood = "monkhood" + case netherlandish = "Netherlandish" + case nonbookish = "nonbookish" + case peonism = "peonism" + case phonelescope = "Phonelescope" + case porphyrogeniture = "porphyrogeniture" + case preindemnify = "preindemnify" + case rosal = "rosal" + case scalenous = "scalenous" + case scopine = "scopine" + case sedaceae = "Sedaceae" + case suberinize = "suberinize" + case symbiot = "symbiot" + case tablefellow = "tablefellow" + case unchargeable = "unchargeable" + } +} + +// MARK: CoadjustClass convenience initializers and mutators + +extension CoadjustClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(CoadjustClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + amidosulphonal: JSONNull?? = nil, + benny: JSONNull?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + ensnare: JSONNull?? = nil, + homocerc: Bool?? = nil, + hybridizer: JSONNull?? = nil, + leastwise: JSONNull?? = nil, + lof: JSONNull?? = nil, + monkhood: JSONNull?? = nil, + netherlandish: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + peonism: JSONNull?? = nil, + phonelescope: JSONNull?? = nil, + porphyrogeniture: JSONNull?? = nil, + preindemnify: JSONNull?? = nil, + rosal: JSONNull?? = nil, + scalenous: JSONNull?? = nil, + scopine: JSONNull?? = nil, + sedaceae: JSONNull?? = nil, + suberinize: JSONNull?? = nil, + symbiot: JSONNull?? = nil, + tablefellow: JSONNull?? = nil, + unchargeable: JSONNull?? = nil + ) -> CoadjustClass { + return CoadjustClass( + amidosulphonal: amidosulphonal ?? self.amidosulphonal, + benny: benny ?? self.benny, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + ensnare: ensnare ?? self.ensnare, + homocerc: homocerc ?? self.homocerc, + hybridizer: hybridizer ?? self.hybridizer, + leastwise: leastwise ?? self.leastwise, + lof: lof ?? self.lof, + monkhood: monkhood ?? self.monkhood, + netherlandish: netherlandish ?? self.netherlandish, + nonbookish: nonbookish ?? self.nonbookish, + peonism: peonism ?? self.peonism, + phonelescope: phonelescope ?? self.phonelescope, + porphyrogeniture: porphyrogeniture ?? self.porphyrogeniture, + preindemnify: preindemnify ?? self.preindemnify, + rosal: rosal ?? self.rosal, + scalenous: scalenous ?? self.scalenous, + scopine: scopine ?? self.scopine, + sedaceae: sedaceae ?? self.sedaceae, + suberinize: suberinize ?? self.suberinize, + symbiot: symbiot ?? self.symbiot, + tablefellow: tablefellow ?? self.tablefellow, + unchargeable: unchargeable ?? self.unchargeable + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Consilience: Codable, Hashable { + case double(Double) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Consilience.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Consilience")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Constructor: Codable, Hashable { + case bool(Bool) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Constructor.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Constructor")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +enum Continuative: Codable, Hashable { + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Continuative.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Continuative")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum CredulityElement: Codable, Hashable { + case credulityClass(CredulityClass) + case integer(Int) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CredulityClass.self) { + self = .credulityClass(x) + return + } + throw DecodingError.typeMismatch(CredulityElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for CredulityElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .credulityClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - CredulityClass +struct CredulityClass: Codable, Hashable { + let ammonolytic: JSONNull? + let bushmaster: JSONNull? + let considering: JSONNull? + let consuetudinary: JSONNull? + let embarras: JSONNull? + let fineness: JSONNull? + let flaithship: JSONNull? + let flavia: JSONNull? + let gruffly: JSONNull? + let hedychium: JSONNull? + let leadwort: JSONNull? + let overseriously: JSONNull? + let parabola: JSONNull? + let pectinatodenticulate: JSONNull? + let popean: JSONNull? + let pornocrat: JSONNull? + let quadrisect: JSONNull? + let seriality: JSONNull? + let vamphorn: JSONNull? + let wharp: JSONNull? + + enum CodingKeys: String, CodingKey { + case ammonolytic = "ammonolytic" + case bushmaster = "bushmaster" + case considering = "considering" + case consuetudinary = "consuetudinary" + case embarras = "embarras" + case fineness = "fineness" + case flaithship = "flaithship" + case flavia = "Flavia" + case gruffly = "gruffly" + case hedychium = "Hedychium" + case leadwort = "leadwort" + case overseriously = "overseriously" + case parabola = "parabola" + case pectinatodenticulate = "pectinatodenticulate" + case popean = "Popean" + case pornocrat = "pornocrat" + case quadrisect = "quadrisect" + case seriality = "seriality" + case vamphorn = "vamphorn" + case wharp = "wharp" + } +} + +// MARK: CredulityClass convenience initializers and mutators + +extension CredulityClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(CredulityClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + ammonolytic: JSONNull?? = nil, + bushmaster: JSONNull?? = nil, + considering: JSONNull?? = nil, + consuetudinary: JSONNull?? = nil, + embarras: JSONNull?? = nil, + fineness: JSONNull?? = nil, + flaithship: JSONNull?? = nil, + flavia: JSONNull?? = nil, + gruffly: JSONNull?? = nil, + hedychium: JSONNull?? = nil, + leadwort: JSONNull?? = nil, + overseriously: JSONNull?? = nil, + parabola: JSONNull?? = nil, + pectinatodenticulate: JSONNull?? = nil, + popean: JSONNull?? = nil, + pornocrat: JSONNull?? = nil, + quadrisect: JSONNull?? = nil, + seriality: JSONNull?? = nil, + vamphorn: JSONNull?? = nil, + wharp: JSONNull?? = nil + ) -> CredulityClass { + return CredulityClass( + ammonolytic: ammonolytic ?? self.ammonolytic, + bushmaster: bushmaster ?? self.bushmaster, + considering: considering ?? self.considering, + consuetudinary: consuetudinary ?? self.consuetudinary, + embarras: embarras ?? self.embarras, + fineness: fineness ?? self.fineness, + flaithship: flaithship ?? self.flaithship, + flavia: flavia ?? self.flavia, + gruffly: gruffly ?? self.gruffly, + hedychium: hedychium ?? self.hedychium, + leadwort: leadwort ?? self.leadwort, + overseriously: overseriously ?? self.overseriously, + parabola: parabola ?? self.parabola, + pectinatodenticulate: pectinatodenticulate ?? self.pectinatodenticulate, + popean: popean ?? self.popean, + pornocrat: pornocrat ?? self.pornocrat, + quadrisect: quadrisect ?? self.quadrisect, + seriality: seriality ?? self.seriality, + vamphorn: vamphorn ?? self.vamphorn, + wharp: wharp ?? self.wharp + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Creviced: Codable, Hashable { + case bool(Bool) + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Creviced.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Creviced")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum DeruralizeElement: Codable, Hashable { + case bool(Bool) + case deruralizeClass(DeruralizeClass) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(DeruralizeClass.self) { + self = .deruralizeClass(x) + return + } + throw DecodingError.typeMismatch(DeruralizeElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for DeruralizeElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .deruralizeClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - DeruralizeClass +struct DeruralizeClass: Codable, Hashable { + let bockerel: JSONNull? + let boulder: JSONNull? + let churrus: JSONNull? + let counterdigged: JSONNull? + let dialogite: JSONNull? + let digenic: JSONNull? + let dunbird: JSONNull? + let ergatogyne: JSONNull? + let fiendful: JSONNull? + let jackrod: JSONNull? + let jehovistic: JSONNull? + let paninean: JSONNull? + let panther: JSONNull? + let placentigerous: JSONNull? + let romney: JSONNull? + let sparm: JSONNull? + let tocsin: JSONNull? + let unnicked: JSONNull? + let unstavable: JSONNull? + let windfirm: JSONNull? + + enum CodingKeys: String, CodingKey { + case bockerel = "bockerel" + case boulder = "boulder" + case churrus = "churrus" + case counterdigged = "counterdigged" + case dialogite = "dialogite" + case digenic = "digenic" + case dunbird = "dunbird" + case ergatogyne = "ergatogyne" + case fiendful = "fiendful" + case jackrod = "jackrod" + case jehovistic = "Jehovistic" + case paninean = "Paninean" + case panther = "panther" + case placentigerous = "placentigerous" + case romney = "Romney" + case sparm = "sparm" + case tocsin = "tocsin" + case unnicked = "unnicked" + case unstavable = "unstavable" + case windfirm = "windfirm" + } +} + +// MARK: DeruralizeClass convenience initializers and mutators + +extension DeruralizeClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(DeruralizeClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + bockerel: JSONNull?? = nil, + boulder: JSONNull?? = nil, + churrus: JSONNull?? = nil, + counterdigged: JSONNull?? = nil, + dialogite: JSONNull?? = nil, + digenic: JSONNull?? = nil, + dunbird: JSONNull?? = nil, + ergatogyne: JSONNull?? = nil, + fiendful: JSONNull?? = nil, + jackrod: JSONNull?? = nil, + jehovistic: JSONNull?? = nil, + paninean: JSONNull?? = nil, + panther: JSONNull?? = nil, + placentigerous: JSONNull?? = nil, + romney: JSONNull?? = nil, + sparm: JSONNull?? = nil, + tocsin: JSONNull?? = nil, + unnicked: JSONNull?? = nil, + unstavable: JSONNull?? = nil, + windfirm: JSONNull?? = nil + ) -> DeruralizeClass { + return DeruralizeClass( + bockerel: bockerel ?? self.bockerel, + boulder: boulder ?? self.boulder, + churrus: churrus ?? self.churrus, + counterdigged: counterdigged ?? self.counterdigged, + dialogite: dialogite ?? self.dialogite, + digenic: digenic ?? self.digenic, + dunbird: dunbird ?? self.dunbird, + ergatogyne: ergatogyne ?? self.ergatogyne, + fiendful: fiendful ?? self.fiendful, + jackrod: jackrod ?? self.jackrod, + jehovistic: jehovistic ?? self.jehovistic, + paninean: paninean ?? self.paninean, + panther: panther ?? self.panther, + placentigerous: placentigerous ?? self.placentigerous, + romney: romney ?? self.romney, + sparm: sparm ?? self.sparm, + tocsin: tocsin ?? self.tocsin, + unnicked: unnicked ?? self.unnicked, + unstavable: unstavable ?? self.unstavable, + windfirm: windfirm ?? self.windfirm + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum DiaereseElement: Codable, Hashable { + case bool(Bool) + case diaereseClass(DiaereseClass) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(DiaereseClass.self) { + self = .diaereseClass(x) + return + } + throw DecodingError.typeMismatch(DiaereseElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for DiaereseElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .diaereseClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - DiaereseClass +struct DiaereseClass: Codable, Hashable { + let amoreuxia: JSONNull? + let ani: JSONNull? + let bernicle: JSONNull? + let blackwasher: JSONNull? + let blowhard: JSONNull? + let broma: JSONNull? + let closecross: JSONNull? + let congregationalism: JSONNull? + let grayly: JSONNull? + let historically: JSONNull? + let hoast: JSONNull? + let irretentive: JSONNull? + let parcener: JSONNull? + let pedder: JSONNull? + let pseudoanatomic: JSONNull? + let rhizocarpian: JSONNull? + let samel: JSONNull? + let silker: JSONNull? + let subdentated: JSONNull? + let subobscure: JSONNull? + + enum CodingKeys: String, CodingKey { + case amoreuxia = "Amoreuxia" + case ani = "ani" + case bernicle = "bernicle" + case blackwasher = "blackwasher" + case blowhard = "blowhard" + case broma = "broma" + case closecross = "closecross" + case congregationalism = "congregationalism" + case grayly = "grayly" + case historically = "historically" + case hoast = "hoast" + case irretentive = "irretentive" + case parcener = "parcener" + case pedder = "pedder" + case pseudoanatomic = "pseudoanatomic" + case rhizocarpian = "rhizocarpian" + case samel = "samel" + case silker = "silker" + case subdentated = "subdentated" + case subobscure = "subobscure" + } +} + +// MARK: DiaereseClass convenience initializers and mutators + +extension DiaereseClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(DiaereseClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + amoreuxia: JSONNull?? = nil, + ani: JSONNull?? = nil, + bernicle: JSONNull?? = nil, + blackwasher: JSONNull?? = nil, + blowhard: JSONNull?? = nil, + broma: JSONNull?? = nil, + closecross: JSONNull?? = nil, + congregationalism: JSONNull?? = nil, + grayly: JSONNull?? = nil, + historically: JSONNull?? = nil, + hoast: JSONNull?? = nil, + irretentive: JSONNull?? = nil, + parcener: JSONNull?? = nil, + pedder: JSONNull?? = nil, + pseudoanatomic: JSONNull?? = nil, + rhizocarpian: JSONNull?? = nil, + samel: JSONNull?? = nil, + silker: JSONNull?? = nil, + subdentated: JSONNull?? = nil, + subobscure: JSONNull?? = nil + ) -> DiaereseClass { + return DiaereseClass( + amoreuxia: amoreuxia ?? self.amoreuxia, + ani: ani ?? self.ani, + bernicle: bernicle ?? self.bernicle, + blackwasher: blackwasher ?? self.blackwasher, + blowhard: blowhard ?? self.blowhard, + broma: broma ?? self.broma, + closecross: closecross ?? self.closecross, + congregationalism: congregationalism ?? self.congregationalism, + grayly: grayly ?? self.grayly, + historically: historically ?? self.historically, + hoast: hoast ?? self.hoast, + irretentive: irretentive ?? self.irretentive, + parcener: parcener ?? self.parcener, + pedder: pedder ?? self.pedder, + pseudoanatomic: pseudoanatomic ?? self.pseudoanatomic, + rhizocarpian: rhizocarpian ?? self.rhizocarpian, + samel: samel ?? self.samel, + silker: silker ?? self.silker, + subdentated: subdentated ?? self.subdentated, + subobscure: subobscure ?? self.subobscure + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Downstroke: Codable, Hashable { + case bool(Bool) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Downstroke.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Downstroke")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Eleutheromania: Codable, Hashable { + case double(Double) + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Eleutheromania.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Eleutheromania")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - Encrust +struct Encrust: Codable, Hashable { + let comradely: JSONNull? + let diacanthous: JSONNull? + let feminineness: JSONNull? + let gossamered: JSONNull? + let hibernia: JSONNull? + let hibiscus: JSONNull? + let lepidosauria: JSONNull? + let lollingly: JSONNull? + let manager: JSONNull? + let mechanic: JSONNull? + let overminuteness: JSONNull? + let papelonne: JSONNull? + let plebification: JSONNull? + let pugmiller: JSONNull? + let recoveror: JSONNull? + let spermatoblastic: JSONNull? + let syllidae: JSONNull? + let ungyved: JSONNull? + let whirlabout: JSONNull? + let woodenware: JSONNull? + + enum CodingKeys: String, CodingKey { + case comradely = "comradely" + case diacanthous = "diacanthous" + case feminineness = "feminineness" + case gossamered = "gossamered" + case hibernia = "Hibernia" + case hibiscus = "Hibiscus" + case lepidosauria = "Lepidosauria" + case lollingly = "lollingly" + case manager = "manager" + case mechanic = "mechanic" + case overminuteness = "overminuteness" + case papelonne = "papelonne" + case plebification = "plebification" + case pugmiller = "pugmiller" + case recoveror = "recoveror" + case spermatoblastic = "spermatoblastic" + case syllidae = "Syllidae" + case ungyved = "ungyved" + case whirlabout = "whirlabout" + case woodenware = "woodenware" + } +} + +// MARK: Encrust convenience initializers and mutators + +extension Encrust { + init(data: Data) throws { + self = try newJSONDecoder().decode(Encrust.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + comradely: JSONNull?? = nil, + diacanthous: JSONNull?? = nil, + feminineness: JSONNull?? = nil, + gossamered: JSONNull?? = nil, + hibernia: JSONNull?? = nil, + hibiscus: JSONNull?? = nil, + lepidosauria: JSONNull?? = nil, + lollingly: JSONNull?? = nil, + manager: JSONNull?? = nil, + mechanic: JSONNull?? = nil, + overminuteness: JSONNull?? = nil, + papelonne: JSONNull?? = nil, + plebification: JSONNull?? = nil, + pugmiller: JSONNull?? = nil, + recoveror: JSONNull?? = nil, + spermatoblastic: JSONNull?? = nil, + syllidae: JSONNull?? = nil, + ungyved: JSONNull?? = nil, + whirlabout: JSONNull?? = nil, + woodenware: JSONNull?? = nil + ) -> Encrust { + return Encrust( + comradely: comradely ?? self.comradely, + diacanthous: diacanthous ?? self.diacanthous, + feminineness: feminineness ?? self.feminineness, + gossamered: gossamered ?? self.gossamered, + hibernia: hibernia ?? self.hibernia, + hibiscus: hibiscus ?? self.hibiscus, + lepidosauria: lepidosauria ?? self.lepidosauria, + lollingly: lollingly ?? self.lollingly, + manager: manager ?? self.manager, + mechanic: mechanic ?? self.mechanic, + overminuteness: overminuteness ?? self.overminuteness, + papelonne: papelonne ?? self.papelonne, + plebification: plebification ?? self.plebification, + pugmiller: pugmiller ?? self.pugmiller, + recoveror: recoveror ?? self.recoveror, + spermatoblastic: spermatoblastic ?? self.spermatoblastic, + syllidae: syllidae ?? self.syllidae, + ungyved: ungyved ?? self.ungyved, + whirlabout: whirlabout ?? self.whirlabout, + woodenware: woodenware ?? self.woodenware + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Entomoid: Codable, Hashable { + case cimeliaClass(CimeliaClass) + case integer(Int) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Entomoid.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Entomoid")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + } + } +} + +enum Epipaleolithic: Codable, Hashable { + case double(Double) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Epipaleolithic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Epipaleolithic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +enum Expropriable: Codable, Hashable { + case cimeliaClass(CimeliaClass) + case double(Double) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Expropriable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Expropriable")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum FagginglyElement: Codable, Hashable { + case double(Double) + case fagginglyClass(FagginglyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(FagginglyClass.self) { + self = .fagginglyClass(x) + return + } + throw DecodingError.typeMismatch(FagginglyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for FagginglyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .fagginglyClass(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - FagginglyClass +struct FagginglyClass: Codable, Hashable { + let abranchian: JSONNull? + let aculeiform: JSONNull? + let adiaphoristic: JSONNull? + let adoptionism: JSONNull? + let anglic: JSONNull? + let antrotomy: JSONNull? + let coerciveness: JSONNull? + let decorist: JSONNull? + let duckhood: JSONNull? + let heteromeri: JSONNull? + let hypochnose: JSONNull? + let lochage: JSONNull? + let melee: JSONNull? + let nonconformitant: JSONNull? + let poinsettia: JSONNull? + let putatively: JSONNull? + let semivolatile: JSONNull? + let soleas: JSONNull? + let unfastenable: JSONNull? + let unmillinered: JSONNull? + + enum CodingKeys: String, CodingKey { + case abranchian = "abranchian" + case aculeiform = "aculeiform" + case adiaphoristic = "adiaphoristic" + case adoptionism = "adoptionism" + case anglic = "Anglic" + case antrotomy = "antrotomy" + case coerciveness = "coerciveness" + case decorist = "decorist" + case duckhood = "duckhood" + case heteromeri = "Heteromeri" + case hypochnose = "hypochnose" + case lochage = "lochage" + case melee = "melee" + case nonconformitant = "nonconformitant" + case poinsettia = "Poinsettia" + case putatively = "putatively" + case semivolatile = "semivolatile" + case soleas = "soleas" + case unfastenable = "unfastenable" + case unmillinered = "unmillinered" + } +} + +// MARK: FagginglyClass convenience initializers and mutators + +extension FagginglyClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(FagginglyClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + abranchian: JSONNull?? = nil, + aculeiform: JSONNull?? = nil, + adiaphoristic: JSONNull?? = nil, + adoptionism: JSONNull?? = nil, + anglic: JSONNull?? = nil, + antrotomy: JSONNull?? = nil, + coerciveness: JSONNull?? = nil, + decorist: JSONNull?? = nil, + duckhood: JSONNull?? = nil, + heteromeri: JSONNull?? = nil, + hypochnose: JSONNull?? = nil, + lochage: JSONNull?? = nil, + melee: JSONNull?? = nil, + nonconformitant: JSONNull?? = nil, + poinsettia: JSONNull?? = nil, + putatively: JSONNull?? = nil, + semivolatile: JSONNull?? = nil, + soleas: JSONNull?? = nil, + unfastenable: JSONNull?? = nil, + unmillinered: JSONNull?? = nil + ) -> FagginglyClass { + return FagginglyClass( + abranchian: abranchian ?? self.abranchian, + aculeiform: aculeiform ?? self.aculeiform, + adiaphoristic: adiaphoristic ?? self.adiaphoristic, + adoptionism: adoptionism ?? self.adoptionism, + anglic: anglic ?? self.anglic, + antrotomy: antrotomy ?? self.antrotomy, + coerciveness: coerciveness ?? self.coerciveness, + decorist: decorist ?? self.decorist, + duckhood: duckhood ?? self.duckhood, + heteromeri: heteromeri ?? self.heteromeri, + hypochnose: hypochnose ?? self.hypochnose, + lochage: lochage ?? self.lochage, + melee: melee ?? self.melee, + nonconformitant: nonconformitant ?? self.nonconformitant, + poinsettia: poinsettia ?? self.poinsettia, + putatively: putatively ?? self.putatively, + semivolatile: semivolatile ?? self.semivolatile, + soleas: soleas ?? self.soleas, + unfastenable: unfastenable ?? self.unfastenable, + unmillinered: unmillinered ?? self.unmillinered + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum FenkElement: Codable, Hashable { + case fenkClass(FenkClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(FenkClass.self) { + self = .fenkClass(x) + return + } + throw DecodingError.typeMismatch(FenkElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for FenkElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .fenkClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - FenkClass +struct FenkClass: Codable, Hashable { + let apoise: JSONNull? + let astronomize: JSONNull? + let cockhorse: JSONNull? + let copular: JSONNull? + let dagomba: JSONNull? + let draffy: JSONNull? + let foreigner: JSONNull? + let guyandot: JSONNull? + let neurogliosis: JSONNull? + let osmious: JSONNull? + let palpitate: JSONNull? + let rebukeable: JSONNull? + let reinwardtia: JSONNull? + let reservatory: JSONNull? + let scalt: JSONNull? + let scripturalize: JSONNull? + let tintometer: JSONNull? + let tritoness: JSONNull? + let undergrade: JSONNull? + let undermountain: JSONNull? + + enum CodingKeys: String, CodingKey { + case apoise = "apoise" + case astronomize = "astronomize" + case cockhorse = "cockhorse" + case copular = "copular" + case dagomba = "Dagomba" + case draffy = "draffy" + case foreigner = "foreigner" + case guyandot = "Guyandot" + case neurogliosis = "neurogliosis" + case osmious = "osmious" + case palpitate = "palpitate" + case rebukeable = "rebukeable" + case reinwardtia = "Reinwardtia" + case reservatory = "reservatory" + case scalt = "scalt" + case scripturalize = "scripturalize" + case tintometer = "tintometer" + case tritoness = "Tritoness" + case undergrade = "undergrade" + case undermountain = "undermountain" + } +} + +// MARK: FenkClass convenience initializers and mutators + +extension FenkClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(FenkClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + apoise: JSONNull?? = nil, + astronomize: JSONNull?? = nil, + cockhorse: JSONNull?? = nil, + copular: JSONNull?? = nil, + dagomba: JSONNull?? = nil, + draffy: JSONNull?? = nil, + foreigner: JSONNull?? = nil, + guyandot: JSONNull?? = nil, + neurogliosis: JSONNull?? = nil, + osmious: JSONNull?? = nil, + palpitate: JSONNull?? = nil, + rebukeable: JSONNull?? = nil, + reinwardtia: JSONNull?? = nil, + reservatory: JSONNull?? = nil, + scalt: JSONNull?? = nil, + scripturalize: JSONNull?? = nil, + tintometer: JSONNull?? = nil, + tritoness: JSONNull?? = nil, + undergrade: JSONNull?? = nil, + undermountain: JSONNull?? = nil + ) -> FenkClass { + return FenkClass( + apoise: apoise ?? self.apoise, + astronomize: astronomize ?? self.astronomize, + cockhorse: cockhorse ?? self.cockhorse, + copular: copular ?? self.copular, + dagomba: dagomba ?? self.dagomba, + draffy: draffy ?? self.draffy, + foreigner: foreigner ?? self.foreigner, + guyandot: guyandot ?? self.guyandot, + neurogliosis: neurogliosis ?? self.neurogliosis, + osmious: osmious ?? self.osmious, + palpitate: palpitate ?? self.palpitate, + rebukeable: rebukeable ?? self.rebukeable, + reinwardtia: reinwardtia ?? self.reinwardtia, + reservatory: reservatory ?? self.reservatory, + scalt: scalt ?? self.scalt, + scripturalize: scripturalize ?? self.scripturalize, + tintometer: tintometer ?? self.tintometer, + tritoness: tritoness ?? self.tritoness, + undergrade: undergrade ?? self.undergrade, + undermountain: undermountain ?? self.undermountain + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum FlagmakingElement: Codable, Hashable { + case bool(Bool) + case double(Double) + case flagmakingClass(FlagmakingClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(FlagmakingClass.self) { + self = .flagmakingClass(x) + return + } + throw DecodingError.typeMismatch(FlagmakingElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for FlagmakingElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .flagmakingClass(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - FlagmakingClass +struct FlagmakingClass: Codable, Hashable { + let albarco: JSONNull? + let bunodonta: JSONNull? + let hornify: JSONNull? + let hydrocorisae: JSONNull? + let hypoglossus: JSONNull? + let inexpiably: JSONNull? + let ingratitude: JSONNull? + let ladyfly: JSONNull? + let medicament: JSONNull? + let monogrammatic: JSONNull? + let nobbut: JSONNull? + let notacanthidae: JSONNull? + let polyplacophore: JSONNull? + let proexercise: JSONNull? + let protoplast: JSONNull? + let puzzling: JSONNull? + let splanchnoskeleton: JSONNull? + let unloveliness: JSONNull? + let unquarantined: JSONNull? + let unrenounceable: JSONNull? + + enum CodingKeys: String, CodingKey { + case albarco = "albarco" + case bunodonta = "Bunodonta" + case hornify = "hornify" + case hydrocorisae = "Hydrocorisae" + case hypoglossus = "hypoglossus" + case inexpiably = "inexpiably" + case ingratitude = "ingratitude" + case ladyfly = "ladyfly" + case medicament = "medicament" + case monogrammatic = "monogrammatic" + case nobbut = "nobbut" + case notacanthidae = "Notacanthidae" + case polyplacophore = "polyplacophore" + case proexercise = "proexercise" + case protoplast = "protoplast" + case puzzling = "puzzling" + case splanchnoskeleton = "splanchnoskeleton" + case unloveliness = "unloveliness" + case unquarantined = "unquarantined" + case unrenounceable = "unrenounceable" + } +} + +// MARK: FlagmakingClass convenience initializers and mutators + +extension FlagmakingClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(FlagmakingClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + albarco: JSONNull?? = nil, + bunodonta: JSONNull?? = nil, + hornify: JSONNull?? = nil, + hydrocorisae: JSONNull?? = nil, + hypoglossus: JSONNull?? = nil, + inexpiably: JSONNull?? = nil, + ingratitude: JSONNull?? = nil, + ladyfly: JSONNull?? = nil, + medicament: JSONNull?? = nil, + monogrammatic: JSONNull?? = nil, + nobbut: JSONNull?? = nil, + notacanthidae: JSONNull?? = nil, + polyplacophore: JSONNull?? = nil, + proexercise: JSONNull?? = nil, + protoplast: JSONNull?? = nil, + puzzling: JSONNull?? = nil, + splanchnoskeleton: JSONNull?? = nil, + unloveliness: JSONNull?? = nil, + unquarantined: JSONNull?? = nil, + unrenounceable: JSONNull?? = nil + ) -> FlagmakingClass { + return FlagmakingClass( + albarco: albarco ?? self.albarco, + bunodonta: bunodonta ?? self.bunodonta, + hornify: hornify ?? self.hornify, + hydrocorisae: hydrocorisae ?? self.hydrocorisae, + hypoglossus: hypoglossus ?? self.hypoglossus, + inexpiably: inexpiably ?? self.inexpiably, + ingratitude: ingratitude ?? self.ingratitude, + ladyfly: ladyfly ?? self.ladyfly, + medicament: medicament ?? self.medicament, + monogrammatic: monogrammatic ?? self.monogrammatic, + nobbut: nobbut ?? self.nobbut, + notacanthidae: notacanthidae ?? self.notacanthidae, + polyplacophore: polyplacophore ?? self.polyplacophore, + proexercise: proexercise ?? self.proexercise, + protoplast: protoplast ?? self.protoplast, + puzzling: puzzling ?? self.puzzling, + splanchnoskeleton: splanchnoskeleton ?? self.splanchnoskeleton, + unloveliness: unloveliness ?? self.unloveliness, + unquarantined: unquarantined ?? self.unquarantined, + unrenounceable: unrenounceable ?? self.unrenounceable + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Fluorometer: Codable, Hashable { + case integer(Int) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Fluorometer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Fluorometer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Fuzzy: Codable, Hashable { + case integer(Int) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Fuzzy.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Fuzzy")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +enum Gardenward: Codable, Hashable { + case bool(Bool) + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Gardenward.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Gardenward")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Generalissimo: Codable, Hashable { + case bool(Bool) + case integerMap([String: Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Generalissimo.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Generalissimo")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Hemicrystalline: Codable, Hashable { + case cimeliaClass(CimeliaClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Hemicrystalline.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hemicrystalline")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum HemocoeleElement: Codable, Hashable { + case hemocoeleClass(HemocoeleClass) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(HemocoeleClass.self) { + self = .hemocoeleClass(x) + return + } + throw DecodingError.typeMismatch(HemocoeleElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for HemocoeleElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .hemocoeleClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - HemocoeleClass +struct HemocoeleClass: Codable, Hashable { + let acrogamy: JSONNull? + let amelification: JSONNull? + let autobiographic: JSONNull? + let berat: JSONNull? + let catharticalness: Double? + let chirotherium: Int? + let disdiapason: String? + let disproportionably: JSONNull? + let erythrite: JSONNull? + let graphic: JSONNull? + let hepatological: JSONNull? + let homocerc: Bool? + let incommensurably: JSONNull? + let misaffirm: JSONNull? + let nonbookish: JSONNull? + let pocketbook: JSONNull? + let sclerometric: JSONNull? + let stambouline: JSONNull? + let stickpin: JSONNull? + let tubulure: JSONNull? + let undelated: JSONNull? + let unsalt: JSONNull? + let untutelar: JSONNull? + let vagrant: JSONNull? + let walt: JSONNull? + + enum CodingKeys: String, CodingKey { + case acrogamy = "acrogamy" + case amelification = "amelification" + case autobiographic = "autobiographic" + case berat = "berat" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case disproportionably = "disproportionably" + case erythrite = "erythrite" + case graphic = "graphic" + case hepatological = "hepatological" + case homocerc = "homocerc" + case incommensurably = "incommensurably" + case misaffirm = "misaffirm" + case nonbookish = "nonbookish" + case pocketbook = "pocketbook" + case sclerometric = "sclerometric" + case stambouline = "stambouline" + case stickpin = "stickpin" + case tubulure = "tubulure" + case undelated = "undelated" + case unsalt = "unsalt" + case untutelar = "untutelar" + case vagrant = "vagrant" + case walt = "Walt" + } +} + +// MARK: HemocoeleClass convenience initializers and mutators + +extension HemocoeleClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(HemocoeleClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acrogamy: JSONNull?? = nil, + amelification: JSONNull?? = nil, + autobiographic: JSONNull?? = nil, + berat: JSONNull?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + disproportionably: JSONNull?? = nil, + erythrite: JSONNull?? = nil, + graphic: JSONNull?? = nil, + hepatological: JSONNull?? = nil, + homocerc: Bool?? = nil, + incommensurably: JSONNull?? = nil, + misaffirm: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + pocketbook: JSONNull?? = nil, + sclerometric: JSONNull?? = nil, + stambouline: JSONNull?? = nil, + stickpin: JSONNull?? = nil, + tubulure: JSONNull?? = nil, + undelated: JSONNull?? = nil, + unsalt: JSONNull?? = nil, + untutelar: JSONNull?? = nil, + vagrant: JSONNull?? = nil, + walt: JSONNull?? = nil + ) -> HemocoeleClass { + return HemocoeleClass( + acrogamy: acrogamy ?? self.acrogamy, + amelification: amelification ?? self.amelification, + autobiographic: autobiographic ?? self.autobiographic, + berat: berat ?? self.berat, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + disproportionably: disproportionably ?? self.disproportionably, + erythrite: erythrite ?? self.erythrite, + graphic: graphic ?? self.graphic, + hepatological: hepatological ?? self.hepatological, + homocerc: homocerc ?? self.homocerc, + incommensurably: incommensurably ?? self.incommensurably, + misaffirm: misaffirm ?? self.misaffirm, + nonbookish: nonbookish ?? self.nonbookish, + pocketbook: pocketbook ?? self.pocketbook, + sclerometric: sclerometric ?? self.sclerometric, + stambouline: stambouline ?? self.stambouline, + stickpin: stickpin ?? self.stickpin, + tubulure: tubulure ?? self.tubulure, + undelated: undelated ?? self.undelated, + unsalt: unsalt ?? self.unsalt, + untutelar: untutelar ?? self.untutelar, + vagrant: vagrant ?? self.vagrant, + walt: walt ?? self.walt + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Hoister: Codable, Hashable { + case cimeliaClass(CimeliaClass) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Hoister.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hoister")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Hyperpiesi: Codable, Hashable { + case cimeliaClass(CimeliaClass) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Hyperpiesi.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hyperpiesi")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Hyppish: Codable, Hashable { + case bool(Bool) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Hyppish.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Hyppish")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Idealizer: Codable, Hashable { + case cimeliaClass(CimeliaClass) + case integer(Int) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Idealizer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Idealizer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Incrustator: Codable, Hashable { + case integer(Int) + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Incrustator.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Incrustator")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Intentiveness: Codable, Hashable { + case cimeliaClass(CimeliaClass) + case double(Double) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(CimeliaClass.self) { + self = .cimeliaClass(x) + return + } + throw DecodingError.typeMismatch(Intentiveness.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Intentiveness")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .cimeliaClass(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - Interacinar +struct Interacinar: Codable, Hashable { + let assapan: Double + let benefactorship: Bool + let triseriatim: String + let tubbing: Int + let untrimmed: JSONNull? + + enum CodingKeys: String, CodingKey { + case assapan = "assapan" + case benefactorship = "benefactorship" + case triseriatim = "triseriatim" + case tubbing = "tubbing" + case untrimmed = "untrimmed" + } +} + +// MARK: Interacinar convenience initializers and mutators + +extension Interacinar { + init(data: Data) throws { + self = try newJSONDecoder().decode(Interacinar.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + assapan: Double? = nil, + benefactorship: Bool? = nil, + triseriatim: String? = nil, + tubbing: Int? = nil, + untrimmed: JSONNull?? = nil + ) -> Interacinar { + return Interacinar( + assapan: assapan ?? self.assapan, + benefactorship: benefactorship ?? self.benefactorship, + triseriatim: triseriatim ?? self.triseriatim, + tubbing: tubbing ?? self.tubbing, + untrimmed: untrimmed ?? self.untrimmed + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Jacutinga: Codable, Hashable { + case integerArray([Int]) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Jacutinga.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Jacutinga")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +// MARK: - Helper functions for creating encoders and decoders + +func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder +} + +func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// MARK: - Encode/decode helpers + +class JSONNull: Codable, Hashable { + + public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool { + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(0) + } + + public init() {} + + public required init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if !container.decodeNil() { + throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull")) + } + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + try container.encodeNil() + } +} diff --git a/head/swift/test/inputs/json/priority/combinations2.json/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift b/head/swift/test/inputs/json/priority/combinations2.json/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift new file mode 100644 index 0000000..9d37c26 --- /dev/null +++ b/head/swift/test/inputs/json/priority/combinations2.json/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift @@ -0,0 +1,2891 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +import Foundation + +// MARK: - TopLevel +final class TopLevel: Codable { + let abranchiata: [Abranchiata] + let academe: [Academe] + let acquirable: [Acquirable] + let aerometry: [Aerometry] + let alexin: [Alexin] + let alleviate: [AlleviateElement] + let amaas: [Amaa] + let ambassage: [Ambassage] + let amphithyron: [Amphithyron?] + let andriana: [String?] + let ankee: [AnkeeElement] + let annihilator: [[String: Int?]?] + let annulose: JSONNull? + let ansarie: [AnsarieElement] + let aphasia: [Aphasia] + let asprawl: [Asprawl] + let attractive: [Bool?] + let barksome: [String: Int] + let bedesman: [Bedesman] + let belard: [Belard] + let bocking: [Bocking] + let brawlingly: [Brawlingly] + let brookie: [Brookie] + let bumboatman: [Bumboatman] + let bystreet: [JSONNull?] + let calaverite: [Calaverite] + let catallactic: [Catallactic] + let cemental: [Cemental] + let chytridiaceae: [ChytridiaceaeElement] + let discordia: [DiscordiaElement] + let endomyces: [Endomyce] + let epinephelidae: [Epinephelidae] + let eupatorium: [Eupatorium] + let gryphosaurus: [GryphosaurusElement] + let koryak: [Koryak] + let lavinia: [LaviniaElement] + let oskar: [OskarElement] + let rebecca: [RebeccaElement] + let rhomboganoidei: [Rhomboganoidei] + let rigsmal: Bool + let ruellia: [Ruellia] + let school: [School] + let shakespearolater: [Shakespearolater] + let svan: [Double] + let wayao: [String: Double] + + enum CodingKeys: String, CodingKey { + case abranchiata = "Abranchiata" + case academe = "academe" + case acquirable = "acquirable" + case aerometry = "aerometry" + case alexin = "alexin" + case alleviate = "alleviate" + case amaas = "amaas" + case ambassage = "ambassage" + case amphithyron = "amphithyron" + case andriana = "Andriana" + case ankee = "ankee" + case annihilator = "annihilator" + case annulose = "annulose" + case ansarie = "Ansarie" + case aphasia = "aphasia" + case asprawl = "asprawl" + case attractive = "attractive" + case barksome = "barksome" + case bedesman = "bedesman" + case belard = "belard" + case bocking = "bocking" + case brawlingly = "brawlingly" + case brookie = "brookie" + case bumboatman = "bumboatman" + case bystreet = "bystreet" + case calaverite = "calaverite" + case catallactic = "catallactic" + case cemental = "cemental" + case chytridiaceae = "Chytridiaceae" + case discordia = "Discordia" + case endomyces = "Endomyces" + case epinephelidae = "Epinephelidae" + case eupatorium = "Eupatorium" + case gryphosaurus = "Gryphosaurus" + case koryak = "Koryak" + case lavinia = "Lavinia" + case oskar = "Oskar" + case rebecca = "Rebecca" + case rhomboganoidei = "Rhomboganoidei" + case rigsmal = "Rigsmal" + case ruellia = "Ruellia" + case school = "School" + case shakespearolater = "Shakespearolater" + case svan = "Svan" + case wayao = "Wayao" + } + + init(abranchiata: [Abranchiata], academe: [Academe], acquirable: [Acquirable], aerometry: [Aerometry], alexin: [Alexin], alleviate: [AlleviateElement], amaas: [Amaa], ambassage: [Ambassage], amphithyron: [Amphithyron?], andriana: [String?], ankee: [AnkeeElement], annihilator: [[String: Int?]?], annulose: JSONNull?, ansarie: [AnsarieElement], aphasia: [Aphasia], asprawl: [Asprawl], attractive: [Bool?], barksome: [String: Int], bedesman: [Bedesman], belard: [Belard], bocking: [Bocking], brawlingly: [Brawlingly], brookie: [Brookie], bumboatman: [Bumboatman], bystreet: [JSONNull?], calaverite: [Calaverite], catallactic: [Catallactic], cemental: [Cemental], chytridiaceae: [ChytridiaceaeElement], discordia: [DiscordiaElement], endomyces: [Endomyce], epinephelidae: [Epinephelidae], eupatorium: [Eupatorium], gryphosaurus: [GryphosaurusElement], koryak: [Koryak], lavinia: [LaviniaElement], oskar: [OskarElement], rebecca: [RebeccaElement], rhomboganoidei: [Rhomboganoidei], rigsmal: Bool, ruellia: [Ruellia], school: [School], shakespearolater: [Shakespearolater], svan: [Double], wayao: [String: Double]) { + self.abranchiata = abranchiata + self.academe = academe + self.acquirable = acquirable + self.aerometry = aerometry + self.alexin = alexin + self.alleviate = alleviate + self.amaas = amaas + self.ambassage = ambassage + self.amphithyron = amphithyron + self.andriana = andriana + self.ankee = ankee + self.annihilator = annihilator + self.annulose = annulose + self.ansarie = ansarie + self.aphasia = aphasia + self.asprawl = asprawl + self.attractive = attractive + self.barksome = barksome + self.bedesman = bedesman + self.belard = belard + self.bocking = bocking + self.brawlingly = brawlingly + self.brookie = brookie + self.bumboatman = bumboatman + self.bystreet = bystreet + self.calaverite = calaverite + self.catallactic = catallactic + self.cemental = cemental + self.chytridiaceae = chytridiaceae + self.discordia = discordia + self.endomyces = endomyces + self.epinephelidae = epinephelidae + self.eupatorium = eupatorium + self.gryphosaurus = gryphosaurus + self.koryak = koryak + self.lavinia = lavinia + self.oskar = oskar + self.rebecca = rebecca + self.rhomboganoidei = rhomboganoidei + self.rigsmal = rigsmal + self.ruellia = ruellia + self.school = school + self.shakespearolater = shakespearolater + self.svan = svan + self.wayao = wayao + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(TopLevel.self, from: data) + self.init(abranchiata: me.abranchiata, academe: me.academe, acquirable: me.acquirable, aerometry: me.aerometry, alexin: me.alexin, alleviate: me.alleviate, amaas: me.amaas, ambassage: me.ambassage, amphithyron: me.amphithyron, andriana: me.andriana, ankee: me.ankee, annihilator: me.annihilator, annulose: me.annulose, ansarie: me.ansarie, aphasia: me.aphasia, asprawl: me.asprawl, attractive: me.attractive, barksome: me.barksome, bedesman: me.bedesman, belard: me.belard, bocking: me.bocking, brawlingly: me.brawlingly, brookie: me.brookie, bumboatman: me.bumboatman, bystreet: me.bystreet, calaverite: me.calaverite, catallactic: me.catallactic, cemental: me.cemental, chytridiaceae: me.chytridiaceae, discordia: me.discordia, endomyces: me.endomyces, epinephelidae: me.epinephelidae, eupatorium: me.eupatorium, gryphosaurus: me.gryphosaurus, koryak: me.koryak, lavinia: me.lavinia, oskar: me.oskar, rebecca: me.rebecca, rhomboganoidei: me.rhomboganoidei, rigsmal: me.rigsmal, ruellia: me.ruellia, school: me.school, shakespearolater: me.shakespearolater, svan: me.svan, wayao: me.wayao) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + abranchiata: [Abranchiata]? = nil, + academe: [Academe]? = nil, + acquirable: [Acquirable]? = nil, + aerometry: [Aerometry]? = nil, + alexin: [Alexin]? = nil, + alleviate: [AlleviateElement]? = nil, + amaas: [Amaa]? = nil, + ambassage: [Ambassage]? = nil, + amphithyron: [Amphithyron?]? = nil, + andriana: [String?]? = nil, + ankee: [AnkeeElement]? = nil, + annihilator: [[String: Int?]?]? = nil, + annulose: JSONNull?? = nil, + ansarie: [AnsarieElement]? = nil, + aphasia: [Aphasia]? = nil, + asprawl: [Asprawl]? = nil, + attractive: [Bool?]? = nil, + barksome: [String: Int]? = nil, + bedesman: [Bedesman]? = nil, + belard: [Belard]? = nil, + bocking: [Bocking]? = nil, + brawlingly: [Brawlingly]? = nil, + brookie: [Brookie]? = nil, + bumboatman: [Bumboatman]? = nil, + bystreet: [JSONNull?]? = nil, + calaverite: [Calaverite]? = nil, + catallactic: [Catallactic]? = nil, + cemental: [Cemental]? = nil, + chytridiaceae: [ChytridiaceaeElement]? = nil, + discordia: [DiscordiaElement]? = nil, + endomyces: [Endomyce]? = nil, + epinephelidae: [Epinephelidae]? = nil, + eupatorium: [Eupatorium]? = nil, + gryphosaurus: [GryphosaurusElement]? = nil, + koryak: [Koryak]? = nil, + lavinia: [LaviniaElement]? = nil, + oskar: [OskarElement]? = nil, + rebecca: [RebeccaElement]? = nil, + rhomboganoidei: [Rhomboganoidei]? = nil, + rigsmal: Bool? = nil, + ruellia: [Ruellia]? = nil, + school: [School]? = nil, + shakespearolater: [Shakespearolater]? = nil, + svan: [Double]? = nil, + wayao: [String: Double]? = nil + ) -> TopLevel { + return TopLevel( + abranchiata: abranchiata ?? self.abranchiata, + academe: academe ?? self.academe, + acquirable: acquirable ?? self.acquirable, + aerometry: aerometry ?? self.aerometry, + alexin: alexin ?? self.alexin, + alleviate: alleviate ?? self.alleviate, + amaas: amaas ?? self.amaas, + ambassage: ambassage ?? self.ambassage, + amphithyron: amphithyron ?? self.amphithyron, + andriana: andriana ?? self.andriana, + ankee: ankee ?? self.ankee, + annihilator: annihilator ?? self.annihilator, + annulose: annulose ?? self.annulose, + ansarie: ansarie ?? self.ansarie, + aphasia: aphasia ?? self.aphasia, + asprawl: asprawl ?? self.asprawl, + attractive: attractive ?? self.attractive, + barksome: barksome ?? self.barksome, + bedesman: bedesman ?? self.bedesman, + belard: belard ?? self.belard, + bocking: bocking ?? self.bocking, + brawlingly: brawlingly ?? self.brawlingly, + brookie: brookie ?? self.brookie, + bumboatman: bumboatman ?? self.bumboatman, + bystreet: bystreet ?? self.bystreet, + calaverite: calaverite ?? self.calaverite, + catallactic: catallactic ?? self.catallactic, + cemental: cemental ?? self.cemental, + chytridiaceae: chytridiaceae ?? self.chytridiaceae, + discordia: discordia ?? self.discordia, + endomyces: endomyces ?? self.endomyces, + epinephelidae: epinephelidae ?? self.epinephelidae, + eupatorium: eupatorium ?? self.eupatorium, + gryphosaurus: gryphosaurus ?? self.gryphosaurus, + koryak: koryak ?? self.koryak, + lavinia: lavinia ?? self.lavinia, + oskar: oskar ?? self.oskar, + rebecca: rebecca ?? self.rebecca, + rhomboganoidei: rhomboganoidei ?? self.rhomboganoidei, + rigsmal: rigsmal ?? self.rigsmal, + ruellia: ruellia ?? self.ruellia, + school: school ?? self.school, + shakespearolater: shakespearolater ?? self.shakespearolater, + svan: svan ?? self.svan, + wayao: wayao ?? self.wayao + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Abranchiata: Codable { + case integer(Int) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Abranchiata.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Abranchiata")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Academe: Codable { + case integer(Int) + case integerArray([Int]) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Academe.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Academe")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Acquirable: Codable { + case integerMap([String: Int]) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Acquirable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Acquirable")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +enum Aerometry: Codable { + case bool(Bool) + case double(Double) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Aerometry.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Aerometry")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + } + } +} + +enum Alexin: Codable { + case bool(Bool) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + throw DecodingError.typeMismatch(Alexin.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Alexin")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +enum AlleviateElement: Codable { + case alleviateClass(AlleviateClass) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode(AlleviateClass.self) { + self = .alleviateClass(x) + return + } + throw DecodingError.typeMismatch(AlleviateElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for AlleviateElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .alleviateClass(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +// MARK: - AlleviateClass +final class AlleviateClass: Codable { + let apriori: JSONNull? + let beggarer: JSONNull? + let brokenheartedly: JSONNull? + let debilitation: JSONNull? + let frike: JSONNull? + let gastrolith: JSONNull? + let hulsean: JSONNull? + let orthocentric: JSONNull? + let petaly: JSONNull? + let probudgeting: JSONNull? + let reacquire: JSONNull? + let scow: JSONNull? + let shutoff: JSONNull? + let subcontiguous: JSONNull? + let suffumigate: JSONNull? + let transformable: JSONNull? + let uncoroneted: JSONNull? + let unparking: JSONNull? + let unvarnishedness: JSONNull? + let wherewithal: JSONNull? + + enum CodingKeys: String, CodingKey { + case apriori = "apriori" + case beggarer = "beggarer" + case brokenheartedly = "brokenheartedly" + case debilitation = "debilitation" + case frike = "frike" + case gastrolith = "gastrolith" + case hulsean = "Hulsean" + case orthocentric = "orthocentric" + case petaly = "petaly" + case probudgeting = "probudgeting" + case reacquire = "reacquire" + case scow = "scow" + case shutoff = "shutoff" + case subcontiguous = "subcontiguous" + case suffumigate = "suffumigate" + case transformable = "transformable" + case uncoroneted = "uncoroneted" + case unparking = "unparking" + case unvarnishedness = "unvarnishedness" + case wherewithal = "wherewithal" + } + + init(apriori: JSONNull?, beggarer: JSONNull?, brokenheartedly: JSONNull?, debilitation: JSONNull?, frike: JSONNull?, gastrolith: JSONNull?, hulsean: JSONNull?, orthocentric: JSONNull?, petaly: JSONNull?, probudgeting: JSONNull?, reacquire: JSONNull?, scow: JSONNull?, shutoff: JSONNull?, subcontiguous: JSONNull?, suffumigate: JSONNull?, transformable: JSONNull?, uncoroneted: JSONNull?, unparking: JSONNull?, unvarnishedness: JSONNull?, wherewithal: JSONNull?) { + self.apriori = apriori + self.beggarer = beggarer + self.brokenheartedly = brokenheartedly + self.debilitation = debilitation + self.frike = frike + self.gastrolith = gastrolith + self.hulsean = hulsean + self.orthocentric = orthocentric + self.petaly = petaly + self.probudgeting = probudgeting + self.reacquire = reacquire + self.scow = scow + self.shutoff = shutoff + self.subcontiguous = subcontiguous + self.suffumigate = suffumigate + self.transformable = transformable + self.uncoroneted = uncoroneted + self.unparking = unparking + self.unvarnishedness = unvarnishedness + self.wherewithal = wherewithal + } +} + +// MARK: AlleviateClass convenience initializers and mutators + +extension AlleviateClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(AlleviateClass.self, from: data) + self.init(apriori: me.apriori, beggarer: me.beggarer, brokenheartedly: me.brokenheartedly, debilitation: me.debilitation, frike: me.frike, gastrolith: me.gastrolith, hulsean: me.hulsean, orthocentric: me.orthocentric, petaly: me.petaly, probudgeting: me.probudgeting, reacquire: me.reacquire, scow: me.scow, shutoff: me.shutoff, subcontiguous: me.subcontiguous, suffumigate: me.suffumigate, transformable: me.transformable, uncoroneted: me.uncoroneted, unparking: me.unparking, unvarnishedness: me.unvarnishedness, wherewithal: me.wherewithal) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + apriori: JSONNull?? = nil, + beggarer: JSONNull?? = nil, + brokenheartedly: JSONNull?? = nil, + debilitation: JSONNull?? = nil, + frike: JSONNull?? = nil, + gastrolith: JSONNull?? = nil, + hulsean: JSONNull?? = nil, + orthocentric: JSONNull?? = nil, + petaly: JSONNull?? = nil, + probudgeting: JSONNull?? = nil, + reacquire: JSONNull?? = nil, + scow: JSONNull?? = nil, + shutoff: JSONNull?? = nil, + subcontiguous: JSONNull?? = nil, + suffumigate: JSONNull?? = nil, + transformable: JSONNull?? = nil, + uncoroneted: JSONNull?? = nil, + unparking: JSONNull?? = nil, + unvarnishedness: JSONNull?? = nil, + wherewithal: JSONNull?? = nil + ) -> AlleviateClass { + return AlleviateClass( + apriori: apriori ?? self.apriori, + beggarer: beggarer ?? self.beggarer, + brokenheartedly: brokenheartedly ?? self.brokenheartedly, + debilitation: debilitation ?? self.debilitation, + frike: frike ?? self.frike, + gastrolith: gastrolith ?? self.gastrolith, + hulsean: hulsean ?? self.hulsean, + orthocentric: orthocentric ?? self.orthocentric, + petaly: petaly ?? self.petaly, + probudgeting: probudgeting ?? self.probudgeting, + reacquire: reacquire ?? self.reacquire, + scow: scow ?? self.scow, + shutoff: shutoff ?? self.shutoff, + subcontiguous: subcontiguous ?? self.subcontiguous, + suffumigate: suffumigate ?? self.suffumigate, + transformable: transformable ?? self.transformable, + uncoroneted: uncoroneted ?? self.uncoroneted, + unparking: unparking ?? self.unparking, + unvarnishedness: unvarnishedness ?? self.unvarnishedness, + wherewithal: wherewithal ?? self.wherewithal + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Amaa: Codable { + case bool(Bool) + case integer(Int) + case rebecca(Rebecca) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Amaa.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Amaa")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + } + } +} + +// MARK: - Rebecca +final class Rebecca: Codable { + let catharticalness: Double + let chirotherium: Int + let disdiapason: String + let homocerc: Bool + let nonbookish: JSONNull? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case homocerc = "homocerc" + case nonbookish = "nonbookish" + } + + init(catharticalness: Double, chirotherium: Int, disdiapason: String, homocerc: Bool, nonbookish: JSONNull?) { + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.homocerc = homocerc + self.nonbookish = nonbookish + } +} + +// MARK: Rebecca convenience initializers and mutators + +extension Rebecca { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Rebecca.self, from: data) + self.init(catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, homocerc: me.homocerc, nonbookish: me.nonbookish) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double? = nil, + chirotherium: Int? = nil, + disdiapason: String? = nil, + homocerc: Bool? = nil, + nonbookish: JSONNull?? = nil + ) -> Rebecca { + return Rebecca( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + homocerc: homocerc ?? self.homocerc, + nonbookish: nonbookish ?? self.nonbookish + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Ambassage: Codable { + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Ambassage.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Ambassage")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - Amphithyron +final class Amphithyron: Codable { + let akroasis: Int? + let antiphonical: Int? + let basebred: Int? + let catharticalness: Double? + let chirotherium: Int? + let conductometric: Int? + let disdiapason: String? + let ensilation: Int? + let eyebolt: Int? + let fistulated: Int? + let heteropod: Int? + let homocerc: Bool? + let juniperus: Int? + let labyrinthically: Int? + let martyrization: Int? + let mispolicy: Int? + let multipara: Int? + let nazirite: Int? + let nonbookish: JSONNull? + let possessorial: Int? + let shamed: Int? + let shelfworn: Int? + let stagnum: Int? + let those: Int? + let undecimal: Int? + + enum CodingKeys: String, CodingKey { + case akroasis = "akroasis" + case antiphonical = "antiphonical" + case basebred = "basebred" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case conductometric = "conductometric" + case disdiapason = "disdiapason" + case ensilation = "ensilation" + case eyebolt = "eyebolt" + case fistulated = "fistulated" + case heteropod = "heteropod" + case homocerc = "homocerc" + case juniperus = "Juniperus" + case labyrinthically = "labyrinthically" + case martyrization = "martyrization" + case mispolicy = "mispolicy" + case multipara = "multipara" + case nazirite = "Nazirite" + case nonbookish = "nonbookish" + case possessorial = "possessorial" + case shamed = "shamed" + case shelfworn = "shelfworn" + case stagnum = "stagnum" + case those = "Those" + case undecimal = "undecimal" + } + + init(akroasis: Int?, antiphonical: Int?, basebred: Int?, catharticalness: Double?, chirotherium: Int?, conductometric: Int?, disdiapason: String?, ensilation: Int?, eyebolt: Int?, fistulated: Int?, heteropod: Int?, homocerc: Bool?, juniperus: Int?, labyrinthically: Int?, martyrization: Int?, mispolicy: Int?, multipara: Int?, nazirite: Int?, nonbookish: JSONNull?, possessorial: Int?, shamed: Int?, shelfworn: Int?, stagnum: Int?, those: Int?, undecimal: Int?) { + self.akroasis = akroasis + self.antiphonical = antiphonical + self.basebred = basebred + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.conductometric = conductometric + self.disdiapason = disdiapason + self.ensilation = ensilation + self.eyebolt = eyebolt + self.fistulated = fistulated + self.heteropod = heteropod + self.homocerc = homocerc + self.juniperus = juniperus + self.labyrinthically = labyrinthically + self.martyrization = martyrization + self.mispolicy = mispolicy + self.multipara = multipara + self.nazirite = nazirite + self.nonbookish = nonbookish + self.possessorial = possessorial + self.shamed = shamed + self.shelfworn = shelfworn + self.stagnum = stagnum + self.those = those + self.undecimal = undecimal + } +} + +// MARK: Amphithyron convenience initializers and mutators + +extension Amphithyron { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Amphithyron.self, from: data) + self.init(akroasis: me.akroasis, antiphonical: me.antiphonical, basebred: me.basebred, catharticalness: me.catharticalness, chirotherium: me.chirotherium, conductometric: me.conductometric, disdiapason: me.disdiapason, ensilation: me.ensilation, eyebolt: me.eyebolt, fistulated: me.fistulated, heteropod: me.heteropod, homocerc: me.homocerc, juniperus: me.juniperus, labyrinthically: me.labyrinthically, martyrization: me.martyrization, mispolicy: me.mispolicy, multipara: me.multipara, nazirite: me.nazirite, nonbookish: me.nonbookish, possessorial: me.possessorial, shamed: me.shamed, shelfworn: me.shelfworn, stagnum: me.stagnum, those: me.those, undecimal: me.undecimal) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + akroasis: Int?? = nil, + antiphonical: Int?? = nil, + basebred: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + conductometric: Int?? = nil, + disdiapason: String?? = nil, + ensilation: Int?? = nil, + eyebolt: Int?? = nil, + fistulated: Int?? = nil, + heteropod: Int?? = nil, + homocerc: Bool?? = nil, + juniperus: Int?? = nil, + labyrinthically: Int?? = nil, + martyrization: Int?? = nil, + mispolicy: Int?? = nil, + multipara: Int?? = nil, + nazirite: Int?? = nil, + nonbookish: JSONNull?? = nil, + possessorial: Int?? = nil, + shamed: Int?? = nil, + shelfworn: Int?? = nil, + stagnum: Int?? = nil, + those: Int?? = nil, + undecimal: Int?? = nil + ) -> Amphithyron { + return Amphithyron( + akroasis: akroasis ?? self.akroasis, + antiphonical: antiphonical ?? self.antiphonical, + basebred: basebred ?? self.basebred, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + conductometric: conductometric ?? self.conductometric, + disdiapason: disdiapason ?? self.disdiapason, + ensilation: ensilation ?? self.ensilation, + eyebolt: eyebolt ?? self.eyebolt, + fistulated: fistulated ?? self.fistulated, + heteropod: heteropod ?? self.heteropod, + homocerc: homocerc ?? self.homocerc, + juniperus: juniperus ?? self.juniperus, + labyrinthically: labyrinthically ?? self.labyrinthically, + martyrization: martyrization ?? self.martyrization, + mispolicy: mispolicy ?? self.mispolicy, + multipara: multipara ?? self.multipara, + nazirite: nazirite ?? self.nazirite, + nonbookish: nonbookish ?? self.nonbookish, + possessorial: possessorial ?? self.possessorial, + shamed: shamed ?? self.shamed, + shelfworn: shelfworn ?? self.shelfworn, + stagnum: stagnum ?? self.stagnum, + those: those ?? self.those, + undecimal: undecimal ?? self.undecimal + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum AnkeeElement: Codable { + case ankeeClass(AnkeeClass) + case integer(Int) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(AnkeeClass.self) { + self = .ankeeClass(x) + return + } + throw DecodingError.typeMismatch(AnkeeElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for AnkeeElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .ankeeClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +// MARK: - AnkeeClass +final class AnkeeClass: Codable { + let anomoean: JSONNull? + let barleyhood: JSONNull? + let befriender: JSONNull? + let brutishness: JSONNull? + let cephalalgy: JSONNull? + let cirurgian: JSONNull? + let conventionally: JSONNull? + let jackshay: JSONNull? + let milammeter: JSONNull? + let naja: JSONNull? + let ombrological: JSONNull? + let phonasthenia: JSONNull? + let retrievableness: JSONNull? + let snakily: JSONNull? + let swot: JSONNull? + let tartlet: JSONNull? + let thiofuran: JSONNull? + let tracheophone: JSONNull? + let tuglike: JSONNull? + let unscratchingly: JSONNull? + + enum CodingKeys: String, CodingKey { + case anomoean = "Anomoean" + case barleyhood = "barleyhood" + case befriender = "befriender" + case brutishness = "brutishness" + case cephalalgy = "cephalalgy" + case cirurgian = "cirurgian" + case conventionally = "conventionally" + case jackshay = "jackshay" + case milammeter = "milammeter" + case naja = "Naja" + case ombrological = "ombrological" + case phonasthenia = "phonasthenia" + case retrievableness = "retrievableness" + case snakily = "snakily" + case swot = "swot" + case tartlet = "tartlet" + case thiofuran = "thiofuran" + case tracheophone = "tracheophone" + case tuglike = "tuglike" + case unscratchingly = "unscratchingly" + } + + init(anomoean: JSONNull?, barleyhood: JSONNull?, befriender: JSONNull?, brutishness: JSONNull?, cephalalgy: JSONNull?, cirurgian: JSONNull?, conventionally: JSONNull?, jackshay: JSONNull?, milammeter: JSONNull?, naja: JSONNull?, ombrological: JSONNull?, phonasthenia: JSONNull?, retrievableness: JSONNull?, snakily: JSONNull?, swot: JSONNull?, tartlet: JSONNull?, thiofuran: JSONNull?, tracheophone: JSONNull?, tuglike: JSONNull?, unscratchingly: JSONNull?) { + self.anomoean = anomoean + self.barleyhood = barleyhood + self.befriender = befriender + self.brutishness = brutishness + self.cephalalgy = cephalalgy + self.cirurgian = cirurgian + self.conventionally = conventionally + self.jackshay = jackshay + self.milammeter = milammeter + self.naja = naja + self.ombrological = ombrological + self.phonasthenia = phonasthenia + self.retrievableness = retrievableness + self.snakily = snakily + self.swot = swot + self.tartlet = tartlet + self.thiofuran = thiofuran + self.tracheophone = tracheophone + self.tuglike = tuglike + self.unscratchingly = unscratchingly + } +} + +// MARK: AnkeeClass convenience initializers and mutators + +extension AnkeeClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(AnkeeClass.self, from: data) + self.init(anomoean: me.anomoean, barleyhood: me.barleyhood, befriender: me.befriender, brutishness: me.brutishness, cephalalgy: me.cephalalgy, cirurgian: me.cirurgian, conventionally: me.conventionally, jackshay: me.jackshay, milammeter: me.milammeter, naja: me.naja, ombrological: me.ombrological, phonasthenia: me.phonasthenia, retrievableness: me.retrievableness, snakily: me.snakily, swot: me.swot, tartlet: me.tartlet, thiofuran: me.thiofuran, tracheophone: me.tracheophone, tuglike: me.tuglike, unscratchingly: me.unscratchingly) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + anomoean: JSONNull?? = nil, + barleyhood: JSONNull?? = nil, + befriender: JSONNull?? = nil, + brutishness: JSONNull?? = nil, + cephalalgy: JSONNull?? = nil, + cirurgian: JSONNull?? = nil, + conventionally: JSONNull?? = nil, + jackshay: JSONNull?? = nil, + milammeter: JSONNull?? = nil, + naja: JSONNull?? = nil, + ombrological: JSONNull?? = nil, + phonasthenia: JSONNull?? = nil, + retrievableness: JSONNull?? = nil, + snakily: JSONNull?? = nil, + swot: JSONNull?? = nil, + tartlet: JSONNull?? = nil, + thiofuran: JSONNull?? = nil, + tracheophone: JSONNull?? = nil, + tuglike: JSONNull?? = nil, + unscratchingly: JSONNull?? = nil + ) -> AnkeeClass { + return AnkeeClass( + anomoean: anomoean ?? self.anomoean, + barleyhood: barleyhood ?? self.barleyhood, + befriender: befriender ?? self.befriender, + brutishness: brutishness ?? self.brutishness, + cephalalgy: cephalalgy ?? self.cephalalgy, + cirurgian: cirurgian ?? self.cirurgian, + conventionally: conventionally ?? self.conventionally, + jackshay: jackshay ?? self.jackshay, + milammeter: milammeter ?? self.milammeter, + naja: naja ?? self.naja, + ombrological: ombrological ?? self.ombrological, + phonasthenia: phonasthenia ?? self.phonasthenia, + retrievableness: retrievableness ?? self.retrievableness, + snakily: snakily ?? self.snakily, + swot: swot ?? self.swot, + tartlet: tartlet ?? self.tartlet, + thiofuran: thiofuran ?? self.thiofuran, + tracheophone: tracheophone ?? self.tracheophone, + tuglike: tuglike ?? self.tuglike, + unscratchingly: unscratchingly ?? self.unscratchingly + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum AnsarieElement: Codable { + case ansarieClass(AnsarieClass) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(AnsarieClass.self) { + self = .ansarieClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(AnsarieElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for AnsarieElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .ansarieClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - AnsarieClass +final class AnsarieClass: Codable { + let accension: JSONNull? + let alida: JSONNull? + let asteria: JSONNull? + let beriberic: JSONNull? + let edgebone: JSONNull? + let gastrodialysis: JSONNull? + let geographic: JSONNull? + let ictonyx: JSONNull? + let metrocele: JSONNull? + let misgraft: JSONNull? + let monteith: JSONNull? + let notcher: JSONNull? + let prorestriction: JSONNull? + let ramist: JSONNull? + let throatlet: JSONNull? + let unfair: JSONNull? + let unsynonymous: JSONNull? + let water: JSONNull? + let zestfully: JSONNull? + let zincic: JSONNull? + + enum CodingKeys: String, CodingKey { + case accension = "accension" + case alida = "Alida" + case asteria = "asteria" + case beriberic = "beriberic" + case edgebone = "edgebone" + case gastrodialysis = "gastrodialysis" + case geographic = "geographic" + case ictonyx = "Ictonyx" + case metrocele = "metrocele" + case misgraft = "misgraft" + case monteith = "monteith" + case notcher = "notcher" + case prorestriction = "prorestriction" + case ramist = "Ramist" + case throatlet = "throatlet" + case unfair = "unfair" + case unsynonymous = "unsynonymous" + case water = "water" + case zestfully = "zestfully" + case zincic = "zincic" + } + + init(accension: JSONNull?, alida: JSONNull?, asteria: JSONNull?, beriberic: JSONNull?, edgebone: JSONNull?, gastrodialysis: JSONNull?, geographic: JSONNull?, ictonyx: JSONNull?, metrocele: JSONNull?, misgraft: JSONNull?, monteith: JSONNull?, notcher: JSONNull?, prorestriction: JSONNull?, ramist: JSONNull?, throatlet: JSONNull?, unfair: JSONNull?, unsynonymous: JSONNull?, water: JSONNull?, zestfully: JSONNull?, zincic: JSONNull?) { + self.accension = accension + self.alida = alida + self.asteria = asteria + self.beriberic = beriberic + self.edgebone = edgebone + self.gastrodialysis = gastrodialysis + self.geographic = geographic + self.ictonyx = ictonyx + self.metrocele = metrocele + self.misgraft = misgraft + self.monteith = monteith + self.notcher = notcher + self.prorestriction = prorestriction + self.ramist = ramist + self.throatlet = throatlet + self.unfair = unfair + self.unsynonymous = unsynonymous + self.water = water + self.zestfully = zestfully + self.zincic = zincic + } +} + +// MARK: AnsarieClass convenience initializers and mutators + +extension AnsarieClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(AnsarieClass.self, from: data) + self.init(accension: me.accension, alida: me.alida, asteria: me.asteria, beriberic: me.beriberic, edgebone: me.edgebone, gastrodialysis: me.gastrodialysis, geographic: me.geographic, ictonyx: me.ictonyx, metrocele: me.metrocele, misgraft: me.misgraft, monteith: me.monteith, notcher: me.notcher, prorestriction: me.prorestriction, ramist: me.ramist, throatlet: me.throatlet, unfair: me.unfair, unsynonymous: me.unsynonymous, water: me.water, zestfully: me.zestfully, zincic: me.zincic) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + accension: JSONNull?? = nil, + alida: JSONNull?? = nil, + asteria: JSONNull?? = nil, + beriberic: JSONNull?? = nil, + edgebone: JSONNull?? = nil, + gastrodialysis: JSONNull?? = nil, + geographic: JSONNull?? = nil, + ictonyx: JSONNull?? = nil, + metrocele: JSONNull?? = nil, + misgraft: JSONNull?? = nil, + monteith: JSONNull?? = nil, + notcher: JSONNull?? = nil, + prorestriction: JSONNull?? = nil, + ramist: JSONNull?? = nil, + throatlet: JSONNull?? = nil, + unfair: JSONNull?? = nil, + unsynonymous: JSONNull?? = nil, + water: JSONNull?? = nil, + zestfully: JSONNull?? = nil, + zincic: JSONNull?? = nil + ) -> AnsarieClass { + return AnsarieClass( + accension: accension ?? self.accension, + alida: alida ?? self.alida, + asteria: asteria ?? self.asteria, + beriberic: beriberic ?? self.beriberic, + edgebone: edgebone ?? self.edgebone, + gastrodialysis: gastrodialysis ?? self.gastrodialysis, + geographic: geographic ?? self.geographic, + ictonyx: ictonyx ?? self.ictonyx, + metrocele: metrocele ?? self.metrocele, + misgraft: misgraft ?? self.misgraft, + monteith: monteith ?? self.monteith, + notcher: notcher ?? self.notcher, + prorestriction: prorestriction ?? self.prorestriction, + ramist: ramist ?? self.ramist, + throatlet: throatlet ?? self.throatlet, + unfair: unfair ?? self.unfair, + unsynonymous: unsynonymous ?? self.unsynonymous, + water: water ?? self.water, + zestfully: zestfully ?? self.zestfully, + zincic: zincic ?? self.zincic + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Aphasia: Codable { + case integer(Int) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + throw DecodingError.typeMismatch(Aphasia.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Aphasia")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +enum Asprawl: Codable { + case double(Double) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Asprawl.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Asprawl")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Bedesman: Codable { + case bool(Bool) + case double(Double) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Bedesman.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Bedesman")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Belard: Codable { + case double(Double) + case integerArray([Int]) + case rebecca(Rebecca) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Belard.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Belard")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + } + } +} + +enum Bocking: Codable { + case bool(Bool) + case integerArray([Int]) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Bocking.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Bocking")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Brawlingly: Codable { + case nullArray([JSONNull?]) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Brawlingly.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Brawlingly")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +enum Brookie: Codable { + case integerArray([Int]) + case rebecca(Rebecca) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Brookie.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Brookie")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + } + } +} + +enum Bumboatman: Codable { + case nullArray([JSONNull?]) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Bumboatman.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Bumboatman")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Calaverite: Codable { + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Calaverite.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Calaverite")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Catallactic: Codable { + case bool(Bool) + case integerMap([String: Int]) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Catallactic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Catallactic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Cemental: Codable { + case double(Double) + case integerArray([Int]) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Cemental.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Cemental")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum ChytridiaceaeElement: Codable { + case bool(Bool) + case chytridiaceaeClass(ChytridiaceaeClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(ChytridiaceaeClass.self) { + self = .chytridiaceaeClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(ChytridiaceaeElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for ChytridiaceaeElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .chytridiaceaeClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - ChytridiaceaeClass +final class ChytridiaceaeClass: Codable { + let batidaceae: JSONNull? + let brechites: JSONNull? + let codespairer: JSONNull? + let emery: JSONNull? + let enervative: JSONNull? + let excriminate: JSONNull? + let goshenite: JSONNull? + let grime: JSONNull? + let gritten: JSONNull? + let hectorly: JSONNull? + let intermediation: JSONNull? + let meeterly: JSONNull? + let narraganset: JSONNull? + let onymatic: JSONNull? + let paddlecock: JSONNull? + let thana: JSONNull? + let thornily: JSONNull? + let uckia: JSONNull? + let unmettle: JSONNull? + let vorticellid: JSONNull? + + enum CodingKeys: String, CodingKey { + case batidaceae = "Batidaceae" + case brechites = "Brechites" + case codespairer = "codespairer" + case emery = "Emery" + case enervative = "enervative" + case excriminate = "excriminate" + case goshenite = "goshenite" + case grime = "grime" + case gritten = "gritten" + case hectorly = "hectorly" + case intermediation = "intermediation" + case meeterly = "meeterly" + case narraganset = "Narraganset" + case onymatic = "onymatic" + case paddlecock = "paddlecock" + case thana = "thana" + case thornily = "thornily" + case uckia = "uckia" + case unmettle = "unmettle" + case vorticellid = "vorticellid" + } + + init(batidaceae: JSONNull?, brechites: JSONNull?, codespairer: JSONNull?, emery: JSONNull?, enervative: JSONNull?, excriminate: JSONNull?, goshenite: JSONNull?, grime: JSONNull?, gritten: JSONNull?, hectorly: JSONNull?, intermediation: JSONNull?, meeterly: JSONNull?, narraganset: JSONNull?, onymatic: JSONNull?, paddlecock: JSONNull?, thana: JSONNull?, thornily: JSONNull?, uckia: JSONNull?, unmettle: JSONNull?, vorticellid: JSONNull?) { + self.batidaceae = batidaceae + self.brechites = brechites + self.codespairer = codespairer + self.emery = emery + self.enervative = enervative + self.excriminate = excriminate + self.goshenite = goshenite + self.grime = grime + self.gritten = gritten + self.hectorly = hectorly + self.intermediation = intermediation + self.meeterly = meeterly + self.narraganset = narraganset + self.onymatic = onymatic + self.paddlecock = paddlecock + self.thana = thana + self.thornily = thornily + self.uckia = uckia + self.unmettle = unmettle + self.vorticellid = vorticellid + } +} + +// MARK: ChytridiaceaeClass convenience initializers and mutators + +extension ChytridiaceaeClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(ChytridiaceaeClass.self, from: data) + self.init(batidaceae: me.batidaceae, brechites: me.brechites, codespairer: me.codespairer, emery: me.emery, enervative: me.enervative, excriminate: me.excriminate, goshenite: me.goshenite, grime: me.grime, gritten: me.gritten, hectorly: me.hectorly, intermediation: me.intermediation, meeterly: me.meeterly, narraganset: me.narraganset, onymatic: me.onymatic, paddlecock: me.paddlecock, thana: me.thana, thornily: me.thornily, uckia: me.uckia, unmettle: me.unmettle, vorticellid: me.vorticellid) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + batidaceae: JSONNull?? = nil, + brechites: JSONNull?? = nil, + codespairer: JSONNull?? = nil, + emery: JSONNull?? = nil, + enervative: JSONNull?? = nil, + excriminate: JSONNull?? = nil, + goshenite: JSONNull?? = nil, + grime: JSONNull?? = nil, + gritten: JSONNull?? = nil, + hectorly: JSONNull?? = nil, + intermediation: JSONNull?? = nil, + meeterly: JSONNull?? = nil, + narraganset: JSONNull?? = nil, + onymatic: JSONNull?? = nil, + paddlecock: JSONNull?? = nil, + thana: JSONNull?? = nil, + thornily: JSONNull?? = nil, + uckia: JSONNull?? = nil, + unmettle: JSONNull?? = nil, + vorticellid: JSONNull?? = nil + ) -> ChytridiaceaeClass { + return ChytridiaceaeClass( + batidaceae: batidaceae ?? self.batidaceae, + brechites: brechites ?? self.brechites, + codespairer: codespairer ?? self.codespairer, + emery: emery ?? self.emery, + enervative: enervative ?? self.enervative, + excriminate: excriminate ?? self.excriminate, + goshenite: goshenite ?? self.goshenite, + grime: grime ?? self.grime, + gritten: gritten ?? self.gritten, + hectorly: hectorly ?? self.hectorly, + intermediation: intermediation ?? self.intermediation, + meeterly: meeterly ?? self.meeterly, + narraganset: narraganset ?? self.narraganset, + onymatic: onymatic ?? self.onymatic, + paddlecock: paddlecock ?? self.paddlecock, + thana: thana ?? self.thana, + thornily: thornily ?? self.thornily, + uckia: uckia ?? self.uckia, + unmettle: unmettle ?? self.unmettle, + vorticellid: vorticellid ?? self.vorticellid + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum DiscordiaElement: Codable { + case discordiaClass(DiscordiaClass) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(DiscordiaClass.self) { + self = .discordiaClass(x) + return + } + throw DecodingError.typeMismatch(DiscordiaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for DiscordiaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .discordiaClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +// MARK: - DiscordiaClass +final class DiscordiaClass: Codable { + let altaic: Int? + let amoristic: Int? + let blennophthalmia: Int? + let catharticalness: Double? + let chirotherium: Int? + let disciplinability: Int? + let disdiapason: String? + let goofer: Int? + let homocerc: Bool? + let laryngograph: Int? + let leucitis: Int? + let lymphocyst: Int? + let microcosmology: Int? + let nauseation: Int? + let nonbookish: JSONNull? + let patarin: Int? + let preliberal: Int? + let prettifier: Int? + let rangework: Int? + let redient: Int? + let subfusiform: Int? + let suicidical: Int? + let swow: Int? + let wastrel: Int? + let wingle: Int? + + enum CodingKeys: String, CodingKey { + case altaic = "Altaic" + case amoristic = "amoristic" + case blennophthalmia = "blennophthalmia" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disciplinability = "disciplinability" + case disdiapason = "disdiapason" + case goofer = "goofer" + case homocerc = "homocerc" + case laryngograph = "laryngograph" + case leucitis = "leucitis" + case lymphocyst = "lymphocyst" + case microcosmology = "microcosmology" + case nauseation = "nauseation" + case nonbookish = "nonbookish" + case patarin = "Patarin" + case preliberal = "preliberal" + case prettifier = "prettifier" + case rangework = "rangework" + case redient = "redient" + case subfusiform = "subfusiform" + case suicidical = "suicidical" + case swow = "swow" + case wastrel = "wastrel" + case wingle = "wingle" + } + + init(altaic: Int?, amoristic: Int?, blennophthalmia: Int?, catharticalness: Double?, chirotherium: Int?, disciplinability: Int?, disdiapason: String?, goofer: Int?, homocerc: Bool?, laryngograph: Int?, leucitis: Int?, lymphocyst: Int?, microcosmology: Int?, nauseation: Int?, nonbookish: JSONNull?, patarin: Int?, preliberal: Int?, prettifier: Int?, rangework: Int?, redient: Int?, subfusiform: Int?, suicidical: Int?, swow: Int?, wastrel: Int?, wingle: Int?) { + self.altaic = altaic + self.amoristic = amoristic + self.blennophthalmia = blennophthalmia + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disciplinability = disciplinability + self.disdiapason = disdiapason + self.goofer = goofer + self.homocerc = homocerc + self.laryngograph = laryngograph + self.leucitis = leucitis + self.lymphocyst = lymphocyst + self.microcosmology = microcosmology + self.nauseation = nauseation + self.nonbookish = nonbookish + self.patarin = patarin + self.preliberal = preliberal + self.prettifier = prettifier + self.rangework = rangework + self.redient = redient + self.subfusiform = subfusiform + self.suicidical = suicidical + self.swow = swow + self.wastrel = wastrel + self.wingle = wingle + } +} + +// MARK: DiscordiaClass convenience initializers and mutators + +extension DiscordiaClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(DiscordiaClass.self, from: data) + self.init(altaic: me.altaic, amoristic: me.amoristic, blennophthalmia: me.blennophthalmia, catharticalness: me.catharticalness, chirotherium: me.chirotherium, disciplinability: me.disciplinability, disdiapason: me.disdiapason, goofer: me.goofer, homocerc: me.homocerc, laryngograph: me.laryngograph, leucitis: me.leucitis, lymphocyst: me.lymphocyst, microcosmology: me.microcosmology, nauseation: me.nauseation, nonbookish: me.nonbookish, patarin: me.patarin, preliberal: me.preliberal, prettifier: me.prettifier, rangework: me.rangework, redient: me.redient, subfusiform: me.subfusiform, suicidical: me.suicidical, swow: me.swow, wastrel: me.wastrel, wingle: me.wingle) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + altaic: Int?? = nil, + amoristic: Int?? = nil, + blennophthalmia: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + disciplinability: Int?? = nil, + disdiapason: String?? = nil, + goofer: Int?? = nil, + homocerc: Bool?? = nil, + laryngograph: Int?? = nil, + leucitis: Int?? = nil, + lymphocyst: Int?? = nil, + microcosmology: Int?? = nil, + nauseation: Int?? = nil, + nonbookish: JSONNull?? = nil, + patarin: Int?? = nil, + preliberal: Int?? = nil, + prettifier: Int?? = nil, + rangework: Int?? = nil, + redient: Int?? = nil, + subfusiform: Int?? = nil, + suicidical: Int?? = nil, + swow: Int?? = nil, + wastrel: Int?? = nil, + wingle: Int?? = nil + ) -> DiscordiaClass { + return DiscordiaClass( + altaic: altaic ?? self.altaic, + amoristic: amoristic ?? self.amoristic, + blennophthalmia: blennophthalmia ?? self.blennophthalmia, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disciplinability: disciplinability ?? self.disciplinability, + disdiapason: disdiapason ?? self.disdiapason, + goofer: goofer ?? self.goofer, + homocerc: homocerc ?? self.homocerc, + laryngograph: laryngograph ?? self.laryngograph, + leucitis: leucitis ?? self.leucitis, + lymphocyst: lymphocyst ?? self.lymphocyst, + microcosmology: microcosmology ?? self.microcosmology, + nauseation: nauseation ?? self.nauseation, + nonbookish: nonbookish ?? self.nonbookish, + patarin: patarin ?? self.patarin, + preliberal: preliberal ?? self.preliberal, + prettifier: prettifier ?? self.prettifier, + rangework: rangework ?? self.rangework, + redient: redient ?? self.redient, + subfusiform: subfusiform ?? self.subfusiform, + suicidical: suicidical ?? self.suicidical, + swow: swow ?? self.swow, + wastrel: wastrel ?? self.wastrel, + wingle: wingle ?? self.wingle + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Endomyce: Codable { + case integer(Int) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Endomyce.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Endomyce")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Epinephelidae: Codable { + case bool(Bool) + case integer(Int) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Epinephelidae.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Epinephelidae")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Eupatorium: Codable { + case integerMap([String: Int]) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Eupatorium.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Eupatorium")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum GryphosaurusElement: Codable { + case gryphosaurusClass(GryphosaurusClass) + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(GryphosaurusClass.self) { + self = .gryphosaurusClass(x) + return + } + throw DecodingError.typeMismatch(GryphosaurusElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for GryphosaurusElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .gryphosaurusClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - GryphosaurusClass +final class GryphosaurusClass: Codable { + let amissibility: JSONNull? + let burushaski: JSONNull? + let citronin: JSONNull? + let coplaintiff: JSONNull? + let disquisitionary: JSONNull? + let enoplan: JSONNull? + let faintness: JSONNull? + let hebetomy: JSONNull? + let islandry: JSONNull? + let lameduck: JSONNull? + let overbattle: JSONNull? + let overinterested: JSONNull? + let phrenologic: JSONNull? + let rainband: JSONNull? + let shiningly: JSONNull? + let stamineous: JSONNull? + let subscapularis: JSONNull? + let tahami: JSONNull? + let undaubed: JSONNull? + let underntime: JSONNull? + + enum CodingKeys: String, CodingKey { + case amissibility = "amissibility" + case burushaski = "Burushaski" + case citronin = "citronin" + case coplaintiff = "coplaintiff" + case disquisitionary = "disquisitionary" + case enoplan = "enoplan" + case faintness = "faintness" + case hebetomy = "hebetomy" + case islandry = "islandry" + case lameduck = "lameduck" + case overbattle = "overbattle" + case overinterested = "overinterested" + case phrenologic = "phrenologic" + case rainband = "rainband" + case shiningly = "shiningly" + case stamineous = "stamineous" + case subscapularis = "subscapularis" + case tahami = "Tahami" + case undaubed = "undaubed" + case underntime = "underntime" + } + + init(amissibility: JSONNull?, burushaski: JSONNull?, citronin: JSONNull?, coplaintiff: JSONNull?, disquisitionary: JSONNull?, enoplan: JSONNull?, faintness: JSONNull?, hebetomy: JSONNull?, islandry: JSONNull?, lameduck: JSONNull?, overbattle: JSONNull?, overinterested: JSONNull?, phrenologic: JSONNull?, rainband: JSONNull?, shiningly: JSONNull?, stamineous: JSONNull?, subscapularis: JSONNull?, tahami: JSONNull?, undaubed: JSONNull?, underntime: JSONNull?) { + self.amissibility = amissibility + self.burushaski = burushaski + self.citronin = citronin + self.coplaintiff = coplaintiff + self.disquisitionary = disquisitionary + self.enoplan = enoplan + self.faintness = faintness + self.hebetomy = hebetomy + self.islandry = islandry + self.lameduck = lameduck + self.overbattle = overbattle + self.overinterested = overinterested + self.phrenologic = phrenologic + self.rainband = rainband + self.shiningly = shiningly + self.stamineous = stamineous + self.subscapularis = subscapularis + self.tahami = tahami + self.undaubed = undaubed + self.underntime = underntime + } +} + +// MARK: GryphosaurusClass convenience initializers and mutators + +extension GryphosaurusClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(GryphosaurusClass.self, from: data) + self.init(amissibility: me.amissibility, burushaski: me.burushaski, citronin: me.citronin, coplaintiff: me.coplaintiff, disquisitionary: me.disquisitionary, enoplan: me.enoplan, faintness: me.faintness, hebetomy: me.hebetomy, islandry: me.islandry, lameduck: me.lameduck, overbattle: me.overbattle, overinterested: me.overinterested, phrenologic: me.phrenologic, rainband: me.rainband, shiningly: me.shiningly, stamineous: me.stamineous, subscapularis: me.subscapularis, tahami: me.tahami, undaubed: me.undaubed, underntime: me.underntime) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + amissibility: JSONNull?? = nil, + burushaski: JSONNull?? = nil, + citronin: JSONNull?? = nil, + coplaintiff: JSONNull?? = nil, + disquisitionary: JSONNull?? = nil, + enoplan: JSONNull?? = nil, + faintness: JSONNull?? = nil, + hebetomy: JSONNull?? = nil, + islandry: JSONNull?? = nil, + lameduck: JSONNull?? = nil, + overbattle: JSONNull?? = nil, + overinterested: JSONNull?? = nil, + phrenologic: JSONNull?? = nil, + rainband: JSONNull?? = nil, + shiningly: JSONNull?? = nil, + stamineous: JSONNull?? = nil, + subscapularis: JSONNull?? = nil, + tahami: JSONNull?? = nil, + undaubed: JSONNull?? = nil, + underntime: JSONNull?? = nil + ) -> GryphosaurusClass { + return GryphosaurusClass( + amissibility: amissibility ?? self.amissibility, + burushaski: burushaski ?? self.burushaski, + citronin: citronin ?? self.citronin, + coplaintiff: coplaintiff ?? self.coplaintiff, + disquisitionary: disquisitionary ?? self.disquisitionary, + enoplan: enoplan ?? self.enoplan, + faintness: faintness ?? self.faintness, + hebetomy: hebetomy ?? self.hebetomy, + islandry: islandry ?? self.islandry, + lameduck: lameduck ?? self.lameduck, + overbattle: overbattle ?? self.overbattle, + overinterested: overinterested ?? self.overinterested, + phrenologic: phrenologic ?? self.phrenologic, + rainband: rainband ?? self.rainband, + shiningly: shiningly ?? self.shiningly, + stamineous: stamineous ?? self.stamineous, + subscapularis: subscapularis ?? self.subscapularis, + tahami: tahami ?? self.tahami, + undaubed: undaubed ?? self.undaubed, + underntime: underntime ?? self.underntime + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Koryak: Codable { + case string(String) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Koryak.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Koryak")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .string(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +enum LaviniaElement: Codable { + case laviniaClass(LaviniaClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(LaviniaClass.self) { + self = .laviniaClass(x) + return + } + throw DecodingError.typeMismatch(LaviniaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LaviniaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .laviniaClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - LaviniaClass +final class LaviniaClass: Codable { + let agitable: Int? + let asininity: Int? + let benefiter: Int? + let bronzelike: Int? + let catharticalness: Double? + let chirotherium: Int? + let cholesteatomatous: Int? + let deprivement: Int? + let disdiapason: String? + let flippantness: Int? + let fogproof: Int? + let homocerc: Bool? + let merrymeeting: Int? + let nonbookish: JSONNull? + let overcareful: Int? + let panaris: Int? + let preacceptance: Int? + let quinoxaline: Int? + let sig: Int? + let superconfusion: Int? + let tacana: Int? + let tillotter: Int? + let tranquillize: Int? + let unquestionable: Int? + let uproute: Int? + + enum CodingKeys: String, CodingKey { + case agitable = "agitable" + case asininity = "asininity" + case benefiter = "benefiter" + case bronzelike = "bronzelike" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case cholesteatomatous = "cholesteatomatous" + case deprivement = "deprivement" + case disdiapason = "disdiapason" + case flippantness = "flippantness" + case fogproof = "fogproof" + case homocerc = "homocerc" + case merrymeeting = "merrymeeting" + case nonbookish = "nonbookish" + case overcareful = "overcareful" + case panaris = "panaris" + case preacceptance = "preacceptance" + case quinoxaline = "quinoxaline" + case sig = "sig" + case superconfusion = "superconfusion" + case tacana = "Tacana" + case tillotter = "tillotter" + case tranquillize = "tranquillize" + case unquestionable = "unquestionable" + case uproute = "uproute" + } + + init(agitable: Int?, asininity: Int?, benefiter: Int?, bronzelike: Int?, catharticalness: Double?, chirotherium: Int?, cholesteatomatous: Int?, deprivement: Int?, disdiapason: String?, flippantness: Int?, fogproof: Int?, homocerc: Bool?, merrymeeting: Int?, nonbookish: JSONNull?, overcareful: Int?, panaris: Int?, preacceptance: Int?, quinoxaline: Int?, sig: Int?, superconfusion: Int?, tacana: Int?, tillotter: Int?, tranquillize: Int?, unquestionable: Int?, uproute: Int?) { + self.agitable = agitable + self.asininity = asininity + self.benefiter = benefiter + self.bronzelike = bronzelike + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.cholesteatomatous = cholesteatomatous + self.deprivement = deprivement + self.disdiapason = disdiapason + self.flippantness = flippantness + self.fogproof = fogproof + self.homocerc = homocerc + self.merrymeeting = merrymeeting + self.nonbookish = nonbookish + self.overcareful = overcareful + self.panaris = panaris + self.preacceptance = preacceptance + self.quinoxaline = quinoxaline + self.sig = sig + self.superconfusion = superconfusion + self.tacana = tacana + self.tillotter = tillotter + self.tranquillize = tranquillize + self.unquestionable = unquestionable + self.uproute = uproute + } +} + +// MARK: LaviniaClass convenience initializers and mutators + +extension LaviniaClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(LaviniaClass.self, from: data) + self.init(agitable: me.agitable, asininity: me.asininity, benefiter: me.benefiter, bronzelike: me.bronzelike, catharticalness: me.catharticalness, chirotherium: me.chirotherium, cholesteatomatous: me.cholesteatomatous, deprivement: me.deprivement, disdiapason: me.disdiapason, flippantness: me.flippantness, fogproof: me.fogproof, homocerc: me.homocerc, merrymeeting: me.merrymeeting, nonbookish: me.nonbookish, overcareful: me.overcareful, panaris: me.panaris, preacceptance: me.preacceptance, quinoxaline: me.quinoxaline, sig: me.sig, superconfusion: me.superconfusion, tacana: me.tacana, tillotter: me.tillotter, tranquillize: me.tranquillize, unquestionable: me.unquestionable, uproute: me.uproute) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + agitable: Int?? = nil, + asininity: Int?? = nil, + benefiter: Int?? = nil, + bronzelike: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + cholesteatomatous: Int?? = nil, + deprivement: Int?? = nil, + disdiapason: String?? = nil, + flippantness: Int?? = nil, + fogproof: Int?? = nil, + homocerc: Bool?? = nil, + merrymeeting: Int?? = nil, + nonbookish: JSONNull?? = nil, + overcareful: Int?? = nil, + panaris: Int?? = nil, + preacceptance: Int?? = nil, + quinoxaline: Int?? = nil, + sig: Int?? = nil, + superconfusion: Int?? = nil, + tacana: Int?? = nil, + tillotter: Int?? = nil, + tranquillize: Int?? = nil, + unquestionable: Int?? = nil, + uproute: Int?? = nil + ) -> LaviniaClass { + return LaviniaClass( + agitable: agitable ?? self.agitable, + asininity: asininity ?? self.asininity, + benefiter: benefiter ?? self.benefiter, + bronzelike: bronzelike ?? self.bronzelike, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + cholesteatomatous: cholesteatomatous ?? self.cholesteatomatous, + deprivement: deprivement ?? self.deprivement, + disdiapason: disdiapason ?? self.disdiapason, + flippantness: flippantness ?? self.flippantness, + fogproof: fogproof ?? self.fogproof, + homocerc: homocerc ?? self.homocerc, + merrymeeting: merrymeeting ?? self.merrymeeting, + nonbookish: nonbookish ?? self.nonbookish, + overcareful: overcareful ?? self.overcareful, + panaris: panaris ?? self.panaris, + preacceptance: preacceptance ?? self.preacceptance, + quinoxaline: quinoxaline ?? self.quinoxaline, + sig: sig ?? self.sig, + superconfusion: superconfusion ?? self.superconfusion, + tacana: tacana ?? self.tacana, + tillotter: tillotter ?? self.tillotter, + tranquillize: tranquillize ?? self.tranquillize, + unquestionable: unquestionable ?? self.unquestionable, + uproute: uproute ?? self.uproute + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum OskarElement: Codable { + case integerArray([Int]) + case oskarClass(OskarClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(OskarClass.self) { + self = .oskarClass(x) + return + } + throw DecodingError.typeMismatch(OskarElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for OskarElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .oskarClass(let x): + try container.encode(x) + } + } +} + +// MARK: - OskarClass +final class OskarClass: Codable { + let acrobates: JSONNull? + let beanshooter: JSONNull? + let bearhound: JSONNull? + let cayuga: JSONNull? + let guarneri: JSONNull? + let hypochondriacism: JSONNull? + let indication: JSONNull? + let jaculative: JSONNull? + let nagana: JSONNull? + let netherlandish: JSONNull? + let noctivagous: JSONNull? + let nonphysiological: JSONNull? + let praxis: JSONNull? + let provision: JSONNull? + let subterhuman: JSONNull? + let sunlit: JSONNull? + let syncraniate: JSONNull? + let teachment: JSONNull? + let unmutinous: JSONNull? + let unstoppable: JSONNull? + + enum CodingKeys: String, CodingKey { + case acrobates = "Acrobates" + case beanshooter = "beanshooter" + case bearhound = "bearhound" + case cayuga = "Cayuga" + case guarneri = "guarneri" + case hypochondriacism = "hypochondriacism" + case indication = "indication" + case jaculative = "jaculative" + case nagana = "nagana" + case netherlandish = "Netherlandish" + case noctivagous = "noctivagous" + case nonphysiological = "nonphysiological" + case praxis = "praxis" + case provision = "provision" + case subterhuman = "subterhuman" + case sunlit = "sunlit" + case syncraniate = "syncraniate" + case teachment = "teachment" + case unmutinous = "unmutinous" + case unstoppable = "unstoppable" + } + + init(acrobates: JSONNull?, beanshooter: JSONNull?, bearhound: JSONNull?, cayuga: JSONNull?, guarneri: JSONNull?, hypochondriacism: JSONNull?, indication: JSONNull?, jaculative: JSONNull?, nagana: JSONNull?, netherlandish: JSONNull?, noctivagous: JSONNull?, nonphysiological: JSONNull?, praxis: JSONNull?, provision: JSONNull?, subterhuman: JSONNull?, sunlit: JSONNull?, syncraniate: JSONNull?, teachment: JSONNull?, unmutinous: JSONNull?, unstoppable: JSONNull?) { + self.acrobates = acrobates + self.beanshooter = beanshooter + self.bearhound = bearhound + self.cayuga = cayuga + self.guarneri = guarneri + self.hypochondriacism = hypochondriacism + self.indication = indication + self.jaculative = jaculative + self.nagana = nagana + self.netherlandish = netherlandish + self.noctivagous = noctivagous + self.nonphysiological = nonphysiological + self.praxis = praxis + self.provision = provision + self.subterhuman = subterhuman + self.sunlit = sunlit + self.syncraniate = syncraniate + self.teachment = teachment + self.unmutinous = unmutinous + self.unstoppable = unstoppable + } +} + +// MARK: OskarClass convenience initializers and mutators + +extension OskarClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(OskarClass.self, from: data) + self.init(acrobates: me.acrobates, beanshooter: me.beanshooter, bearhound: me.bearhound, cayuga: me.cayuga, guarneri: me.guarneri, hypochondriacism: me.hypochondriacism, indication: me.indication, jaculative: me.jaculative, nagana: me.nagana, netherlandish: me.netherlandish, noctivagous: me.noctivagous, nonphysiological: me.nonphysiological, praxis: me.praxis, provision: me.provision, subterhuman: me.subterhuman, sunlit: me.sunlit, syncraniate: me.syncraniate, teachment: me.teachment, unmutinous: me.unmutinous, unstoppable: me.unstoppable) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acrobates: JSONNull?? = nil, + beanshooter: JSONNull?? = nil, + bearhound: JSONNull?? = nil, + cayuga: JSONNull?? = nil, + guarneri: JSONNull?? = nil, + hypochondriacism: JSONNull?? = nil, + indication: JSONNull?? = nil, + jaculative: JSONNull?? = nil, + nagana: JSONNull?? = nil, + netherlandish: JSONNull?? = nil, + noctivagous: JSONNull?? = nil, + nonphysiological: JSONNull?? = nil, + praxis: JSONNull?? = nil, + provision: JSONNull?? = nil, + subterhuman: JSONNull?? = nil, + sunlit: JSONNull?? = nil, + syncraniate: JSONNull?? = nil, + teachment: JSONNull?? = nil, + unmutinous: JSONNull?? = nil, + unstoppable: JSONNull?? = nil + ) -> OskarClass { + return OskarClass( + acrobates: acrobates ?? self.acrobates, + beanshooter: beanshooter ?? self.beanshooter, + bearhound: bearhound ?? self.bearhound, + cayuga: cayuga ?? self.cayuga, + guarneri: guarneri ?? self.guarneri, + hypochondriacism: hypochondriacism ?? self.hypochondriacism, + indication: indication ?? self.indication, + jaculative: jaculative ?? self.jaculative, + nagana: nagana ?? self.nagana, + netherlandish: netherlandish ?? self.netherlandish, + noctivagous: noctivagous ?? self.noctivagous, + nonphysiological: nonphysiological ?? self.nonphysiological, + praxis: praxis ?? self.praxis, + provision: provision ?? self.provision, + subterhuman: subterhuman ?? self.subterhuman, + sunlit: sunlit ?? self.sunlit, + syncraniate: syncraniate ?? self.syncraniate, + teachment: teachment ?? self.teachment, + unmutinous: unmutinous ?? self.unmutinous, + unstoppable: unstoppable ?? self.unstoppable + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum RebeccaElement: Codable { + case integer(Int) + case rebecca(Rebecca) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(RebeccaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for RebeccaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Rhomboganoidei: Codable { + case integerArray([Int]) + case rebecca(Rebecca) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Rhomboganoidei.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Rhomboganoidei")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Ruellia: Codable { + case bool(Bool) + case rebecca(Rebecca) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Ruellia.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Ruellia")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum School: Codable { + case integer(Int) + case integerMap([String: Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(School.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for School")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Shakespearolater: Codable { + case double(Double) + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Shakespearolater.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Shakespearolater")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - Helper functions for creating encoders and decoders + +func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder +} + +func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// MARK: - Encode/decode helpers + +final class JSONNull: Codable, Hashable { + + public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool { + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(0) + } + + public init() {} + + public required init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if !container.decodeNil() { + throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull")) + } + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + try container.encodeNil() + } +} diff --git a/head/swift/test/inputs/json/priority/combinations2.json/protocol-hashable--739b516c7897/quicktype.swift b/head/swift/test/inputs/json/priority/combinations2.json/protocol-hashable--739b516c7897/quicktype.swift new file mode 100644 index 0000000..df9a33c --- /dev/null +++ b/head/swift/test/inputs/json/priority/combinations2.json/protocol-hashable--739b516c7897/quicktype.swift @@ -0,0 +1,2668 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +import Foundation + +// MARK: - TopLevel +struct TopLevel: Codable, Hashable { + let abranchiata: [Abranchiata] + let academe: [Academe] + let acquirable: [Acquirable] + let aerometry: [Aerometry] + let alexin: [Alexin] + let alleviate: [AlleviateElement] + let amaas: [Amaa] + let ambassage: [Ambassage] + let amphithyron: [Amphithyron?] + let andriana: [String?] + let ankee: [AnkeeElement] + let annihilator: [[String: Int?]?] + let annulose: JSONNull? + let ansarie: [AnsarieElement] + let aphasia: [Aphasia] + let asprawl: [Asprawl] + let attractive: [Bool?] + let barksome: [String: Int] + let bedesman: [Bedesman] + let belard: [Belard] + let bocking: [Bocking] + let brawlingly: [Brawlingly] + let brookie: [Brookie] + let bumboatman: [Bumboatman] + let bystreet: [JSONNull?] + let calaverite: [Calaverite] + let catallactic: [Catallactic] + let cemental: [Cemental] + let chytridiaceae: [ChytridiaceaeElement] + let discordia: [DiscordiaElement] + let endomyces: [Endomyce] + let epinephelidae: [Epinephelidae] + let eupatorium: [Eupatorium] + let gryphosaurus: [GryphosaurusElement] + let koryak: [Koryak] + let lavinia: [LaviniaElement] + let oskar: [OskarElement] + let rebecca: [RebeccaElement] + let rhomboganoidei: [Rhomboganoidei] + let rigsmal: Bool + let ruellia: [Ruellia] + let school: [School] + let shakespearolater: [Shakespearolater] + let svan: [Double] + let wayao: [String: Double] + + enum CodingKeys: String, CodingKey { + case abranchiata = "Abranchiata" + case academe = "academe" + case acquirable = "acquirable" + case aerometry = "aerometry" + case alexin = "alexin" + case alleviate = "alleviate" + case amaas = "amaas" + case ambassage = "ambassage" + case amphithyron = "amphithyron" + case andriana = "Andriana" + case ankee = "ankee" + case annihilator = "annihilator" + case annulose = "annulose" + case ansarie = "Ansarie" + case aphasia = "aphasia" + case asprawl = "asprawl" + case attractive = "attractive" + case barksome = "barksome" + case bedesman = "bedesman" + case belard = "belard" + case bocking = "bocking" + case brawlingly = "brawlingly" + case brookie = "brookie" + case bumboatman = "bumboatman" + case bystreet = "bystreet" + case calaverite = "calaverite" + case catallactic = "catallactic" + case cemental = "cemental" + case chytridiaceae = "Chytridiaceae" + case discordia = "Discordia" + case endomyces = "Endomyces" + case epinephelidae = "Epinephelidae" + case eupatorium = "Eupatorium" + case gryphosaurus = "Gryphosaurus" + case koryak = "Koryak" + case lavinia = "Lavinia" + case oskar = "Oskar" + case rebecca = "Rebecca" + case rhomboganoidei = "Rhomboganoidei" + case rigsmal = "Rigsmal" + case ruellia = "Ruellia" + case school = "School" + case shakespearolater = "Shakespearolater" + case svan = "Svan" + case wayao = "Wayao" + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + init(data: Data) throws { + self = try newJSONDecoder().decode(TopLevel.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + abranchiata: [Abranchiata]? = nil, + academe: [Academe]? = nil, + acquirable: [Acquirable]? = nil, + aerometry: [Aerometry]? = nil, + alexin: [Alexin]? = nil, + alleviate: [AlleviateElement]? = nil, + amaas: [Amaa]? = nil, + ambassage: [Ambassage]? = nil, + amphithyron: [Amphithyron?]? = nil, + andriana: [String?]? = nil, + ankee: [AnkeeElement]? = nil, + annihilator: [[String: Int?]?]? = nil, + annulose: JSONNull?? = nil, + ansarie: [AnsarieElement]? = nil, + aphasia: [Aphasia]? = nil, + asprawl: [Asprawl]? = nil, + attractive: [Bool?]? = nil, + barksome: [String: Int]? = nil, + bedesman: [Bedesman]? = nil, + belard: [Belard]? = nil, + bocking: [Bocking]? = nil, + brawlingly: [Brawlingly]? = nil, + brookie: [Brookie]? = nil, + bumboatman: [Bumboatman]? = nil, + bystreet: [JSONNull?]? = nil, + calaverite: [Calaverite]? = nil, + catallactic: [Catallactic]? = nil, + cemental: [Cemental]? = nil, + chytridiaceae: [ChytridiaceaeElement]? = nil, + discordia: [DiscordiaElement]? = nil, + endomyces: [Endomyce]? = nil, + epinephelidae: [Epinephelidae]? = nil, + eupatorium: [Eupatorium]? = nil, + gryphosaurus: [GryphosaurusElement]? = nil, + koryak: [Koryak]? = nil, + lavinia: [LaviniaElement]? = nil, + oskar: [OskarElement]? = nil, + rebecca: [RebeccaElement]? = nil, + rhomboganoidei: [Rhomboganoidei]? = nil, + rigsmal: Bool? = nil, + ruellia: [Ruellia]? = nil, + school: [School]? = nil, + shakespearolater: [Shakespearolater]? = nil, + svan: [Double]? = nil, + wayao: [String: Double]? = nil + ) -> TopLevel { + return TopLevel( + abranchiata: abranchiata ?? self.abranchiata, + academe: academe ?? self.academe, + acquirable: acquirable ?? self.acquirable, + aerometry: aerometry ?? self.aerometry, + alexin: alexin ?? self.alexin, + alleviate: alleviate ?? self.alleviate, + amaas: amaas ?? self.amaas, + ambassage: ambassage ?? self.ambassage, + amphithyron: amphithyron ?? self.amphithyron, + andriana: andriana ?? self.andriana, + ankee: ankee ?? self.ankee, + annihilator: annihilator ?? self.annihilator, + annulose: annulose ?? self.annulose, + ansarie: ansarie ?? self.ansarie, + aphasia: aphasia ?? self.aphasia, + asprawl: asprawl ?? self.asprawl, + attractive: attractive ?? self.attractive, + barksome: barksome ?? self.barksome, + bedesman: bedesman ?? self.bedesman, + belard: belard ?? self.belard, + bocking: bocking ?? self.bocking, + brawlingly: brawlingly ?? self.brawlingly, + brookie: brookie ?? self.brookie, + bumboatman: bumboatman ?? self.bumboatman, + bystreet: bystreet ?? self.bystreet, + calaverite: calaverite ?? self.calaverite, + catallactic: catallactic ?? self.catallactic, + cemental: cemental ?? self.cemental, + chytridiaceae: chytridiaceae ?? self.chytridiaceae, + discordia: discordia ?? self.discordia, + endomyces: endomyces ?? self.endomyces, + epinephelidae: epinephelidae ?? self.epinephelidae, + eupatorium: eupatorium ?? self.eupatorium, + gryphosaurus: gryphosaurus ?? self.gryphosaurus, + koryak: koryak ?? self.koryak, + lavinia: lavinia ?? self.lavinia, + oskar: oskar ?? self.oskar, + rebecca: rebecca ?? self.rebecca, + rhomboganoidei: rhomboganoidei ?? self.rhomboganoidei, + rigsmal: rigsmal ?? self.rigsmal, + ruellia: ruellia ?? self.ruellia, + school: school ?? self.school, + shakespearolater: shakespearolater ?? self.shakespearolater, + svan: svan ?? self.svan, + wayao: wayao ?? self.wayao + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Abranchiata: Codable, Hashable { + case integer(Int) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Abranchiata.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Abranchiata")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Academe: Codable, Hashable { + case integer(Int) + case integerArray([Int]) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Academe.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Academe")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Acquirable: Codable, Hashable { + case integerMap([String: Int]) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Acquirable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Acquirable")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +enum Aerometry: Codable, Hashable { + case bool(Bool) + case double(Double) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Aerometry.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Aerometry")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + } + } +} + +enum Alexin: Codable, Hashable { + case bool(Bool) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + throw DecodingError.typeMismatch(Alexin.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Alexin")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +enum AlleviateElement: Codable, Hashable { + case alleviateClass(AlleviateClass) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode(AlleviateClass.self) { + self = .alleviateClass(x) + return + } + throw DecodingError.typeMismatch(AlleviateElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for AlleviateElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .alleviateClass(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - AlleviateClass +struct AlleviateClass: Codable, Hashable { + let apriori: JSONNull? + let beggarer: JSONNull? + let brokenheartedly: JSONNull? + let debilitation: JSONNull? + let frike: JSONNull? + let gastrolith: JSONNull? + let hulsean: JSONNull? + let orthocentric: JSONNull? + let petaly: JSONNull? + let probudgeting: JSONNull? + let reacquire: JSONNull? + let scow: JSONNull? + let shutoff: JSONNull? + let subcontiguous: JSONNull? + let suffumigate: JSONNull? + let transformable: JSONNull? + let uncoroneted: JSONNull? + let unparking: JSONNull? + let unvarnishedness: JSONNull? + let wherewithal: JSONNull? + + enum CodingKeys: String, CodingKey { + case apriori = "apriori" + case beggarer = "beggarer" + case brokenheartedly = "brokenheartedly" + case debilitation = "debilitation" + case frike = "frike" + case gastrolith = "gastrolith" + case hulsean = "Hulsean" + case orthocentric = "orthocentric" + case petaly = "petaly" + case probudgeting = "probudgeting" + case reacquire = "reacquire" + case scow = "scow" + case shutoff = "shutoff" + case subcontiguous = "subcontiguous" + case suffumigate = "suffumigate" + case transformable = "transformable" + case uncoroneted = "uncoroneted" + case unparking = "unparking" + case unvarnishedness = "unvarnishedness" + case wherewithal = "wherewithal" + } +} + +// MARK: AlleviateClass convenience initializers and mutators + +extension AlleviateClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(AlleviateClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + apriori: JSONNull?? = nil, + beggarer: JSONNull?? = nil, + brokenheartedly: JSONNull?? = nil, + debilitation: JSONNull?? = nil, + frike: JSONNull?? = nil, + gastrolith: JSONNull?? = nil, + hulsean: JSONNull?? = nil, + orthocentric: JSONNull?? = nil, + petaly: JSONNull?? = nil, + probudgeting: JSONNull?? = nil, + reacquire: JSONNull?? = nil, + scow: JSONNull?? = nil, + shutoff: JSONNull?? = nil, + subcontiguous: JSONNull?? = nil, + suffumigate: JSONNull?? = nil, + transformable: JSONNull?? = nil, + uncoroneted: JSONNull?? = nil, + unparking: JSONNull?? = nil, + unvarnishedness: JSONNull?? = nil, + wherewithal: JSONNull?? = nil + ) -> AlleviateClass { + return AlleviateClass( + apriori: apriori ?? self.apriori, + beggarer: beggarer ?? self.beggarer, + brokenheartedly: brokenheartedly ?? self.brokenheartedly, + debilitation: debilitation ?? self.debilitation, + frike: frike ?? self.frike, + gastrolith: gastrolith ?? self.gastrolith, + hulsean: hulsean ?? self.hulsean, + orthocentric: orthocentric ?? self.orthocentric, + petaly: petaly ?? self.petaly, + probudgeting: probudgeting ?? self.probudgeting, + reacquire: reacquire ?? self.reacquire, + scow: scow ?? self.scow, + shutoff: shutoff ?? self.shutoff, + subcontiguous: subcontiguous ?? self.subcontiguous, + suffumigate: suffumigate ?? self.suffumigate, + transformable: transformable ?? self.transformable, + uncoroneted: uncoroneted ?? self.uncoroneted, + unparking: unparking ?? self.unparking, + unvarnishedness: unvarnishedness ?? self.unvarnishedness, + wherewithal: wherewithal ?? self.wherewithal + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Amaa: Codable, Hashable { + case bool(Bool) + case integer(Int) + case rebecca(Rebecca) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Amaa.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Amaa")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - Rebecca +struct Rebecca: Codable, Hashable { + let catharticalness: Double + let chirotherium: Int + let disdiapason: String + let homocerc: Bool + let nonbookish: JSONNull? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case homocerc = "homocerc" + case nonbookish = "nonbookish" + } +} + +// MARK: Rebecca convenience initializers and mutators + +extension Rebecca { + init(data: Data) throws { + self = try newJSONDecoder().decode(Rebecca.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double? = nil, + chirotherium: Int? = nil, + disdiapason: String? = nil, + homocerc: Bool? = nil, + nonbookish: JSONNull?? = nil + ) -> Rebecca { + return Rebecca( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + homocerc: homocerc ?? self.homocerc, + nonbookish: nonbookish ?? self.nonbookish + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Ambassage: Codable, Hashable { + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Ambassage.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Ambassage")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - Amphithyron +struct Amphithyron: Codable, Hashable { + let akroasis: Int? + let antiphonical: Int? + let basebred: Int? + let catharticalness: Double? + let chirotherium: Int? + let conductometric: Int? + let disdiapason: String? + let ensilation: Int? + let eyebolt: Int? + let fistulated: Int? + let heteropod: Int? + let homocerc: Bool? + let juniperus: Int? + let labyrinthically: Int? + let martyrization: Int? + let mispolicy: Int? + let multipara: Int? + let nazirite: Int? + let nonbookish: JSONNull? + let possessorial: Int? + let shamed: Int? + let shelfworn: Int? + let stagnum: Int? + let those: Int? + let undecimal: Int? + + enum CodingKeys: String, CodingKey { + case akroasis = "akroasis" + case antiphonical = "antiphonical" + case basebred = "basebred" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case conductometric = "conductometric" + case disdiapason = "disdiapason" + case ensilation = "ensilation" + case eyebolt = "eyebolt" + case fistulated = "fistulated" + case heteropod = "heteropod" + case homocerc = "homocerc" + case juniperus = "Juniperus" + case labyrinthically = "labyrinthically" + case martyrization = "martyrization" + case mispolicy = "mispolicy" + case multipara = "multipara" + case nazirite = "Nazirite" + case nonbookish = "nonbookish" + case possessorial = "possessorial" + case shamed = "shamed" + case shelfworn = "shelfworn" + case stagnum = "stagnum" + case those = "Those" + case undecimal = "undecimal" + } +} + +// MARK: Amphithyron convenience initializers and mutators + +extension Amphithyron { + init(data: Data) throws { + self = try newJSONDecoder().decode(Amphithyron.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + akroasis: Int?? = nil, + antiphonical: Int?? = nil, + basebred: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + conductometric: Int?? = nil, + disdiapason: String?? = nil, + ensilation: Int?? = nil, + eyebolt: Int?? = nil, + fistulated: Int?? = nil, + heteropod: Int?? = nil, + homocerc: Bool?? = nil, + juniperus: Int?? = nil, + labyrinthically: Int?? = nil, + martyrization: Int?? = nil, + mispolicy: Int?? = nil, + multipara: Int?? = nil, + nazirite: Int?? = nil, + nonbookish: JSONNull?? = nil, + possessorial: Int?? = nil, + shamed: Int?? = nil, + shelfworn: Int?? = nil, + stagnum: Int?? = nil, + those: Int?? = nil, + undecimal: Int?? = nil + ) -> Amphithyron { + return Amphithyron( + akroasis: akroasis ?? self.akroasis, + antiphonical: antiphonical ?? self.antiphonical, + basebred: basebred ?? self.basebred, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + conductometric: conductometric ?? self.conductometric, + disdiapason: disdiapason ?? self.disdiapason, + ensilation: ensilation ?? self.ensilation, + eyebolt: eyebolt ?? self.eyebolt, + fistulated: fistulated ?? self.fistulated, + heteropod: heteropod ?? self.heteropod, + homocerc: homocerc ?? self.homocerc, + juniperus: juniperus ?? self.juniperus, + labyrinthically: labyrinthically ?? self.labyrinthically, + martyrization: martyrization ?? self.martyrization, + mispolicy: mispolicy ?? self.mispolicy, + multipara: multipara ?? self.multipara, + nazirite: nazirite ?? self.nazirite, + nonbookish: nonbookish ?? self.nonbookish, + possessorial: possessorial ?? self.possessorial, + shamed: shamed ?? self.shamed, + shelfworn: shelfworn ?? self.shelfworn, + stagnum: stagnum ?? self.stagnum, + those: those ?? self.those, + undecimal: undecimal ?? self.undecimal + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum AnkeeElement: Codable, Hashable { + case ankeeClass(AnkeeClass) + case integer(Int) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(AnkeeClass.self) { + self = .ankeeClass(x) + return + } + throw DecodingError.typeMismatch(AnkeeElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for AnkeeElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .ankeeClass(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - AnkeeClass +struct AnkeeClass: Codable, Hashable { + let anomoean: JSONNull? + let barleyhood: JSONNull? + let befriender: JSONNull? + let brutishness: JSONNull? + let cephalalgy: JSONNull? + let cirurgian: JSONNull? + let conventionally: JSONNull? + let jackshay: JSONNull? + let milammeter: JSONNull? + let naja: JSONNull? + let ombrological: JSONNull? + let phonasthenia: JSONNull? + let retrievableness: JSONNull? + let snakily: JSONNull? + let swot: JSONNull? + let tartlet: JSONNull? + let thiofuran: JSONNull? + let tracheophone: JSONNull? + let tuglike: JSONNull? + let unscratchingly: JSONNull? + + enum CodingKeys: String, CodingKey { + case anomoean = "Anomoean" + case barleyhood = "barleyhood" + case befriender = "befriender" + case brutishness = "brutishness" + case cephalalgy = "cephalalgy" + case cirurgian = "cirurgian" + case conventionally = "conventionally" + case jackshay = "jackshay" + case milammeter = "milammeter" + case naja = "Naja" + case ombrological = "ombrological" + case phonasthenia = "phonasthenia" + case retrievableness = "retrievableness" + case snakily = "snakily" + case swot = "swot" + case tartlet = "tartlet" + case thiofuran = "thiofuran" + case tracheophone = "tracheophone" + case tuglike = "tuglike" + case unscratchingly = "unscratchingly" + } +} + +// MARK: AnkeeClass convenience initializers and mutators + +extension AnkeeClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(AnkeeClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + anomoean: JSONNull?? = nil, + barleyhood: JSONNull?? = nil, + befriender: JSONNull?? = nil, + brutishness: JSONNull?? = nil, + cephalalgy: JSONNull?? = nil, + cirurgian: JSONNull?? = nil, + conventionally: JSONNull?? = nil, + jackshay: JSONNull?? = nil, + milammeter: JSONNull?? = nil, + naja: JSONNull?? = nil, + ombrological: JSONNull?? = nil, + phonasthenia: JSONNull?? = nil, + retrievableness: JSONNull?? = nil, + snakily: JSONNull?? = nil, + swot: JSONNull?? = nil, + tartlet: JSONNull?? = nil, + thiofuran: JSONNull?? = nil, + tracheophone: JSONNull?? = nil, + tuglike: JSONNull?? = nil, + unscratchingly: JSONNull?? = nil + ) -> AnkeeClass { + return AnkeeClass( + anomoean: anomoean ?? self.anomoean, + barleyhood: barleyhood ?? self.barleyhood, + befriender: befriender ?? self.befriender, + brutishness: brutishness ?? self.brutishness, + cephalalgy: cephalalgy ?? self.cephalalgy, + cirurgian: cirurgian ?? self.cirurgian, + conventionally: conventionally ?? self.conventionally, + jackshay: jackshay ?? self.jackshay, + milammeter: milammeter ?? self.milammeter, + naja: naja ?? self.naja, + ombrological: ombrological ?? self.ombrological, + phonasthenia: phonasthenia ?? self.phonasthenia, + retrievableness: retrievableness ?? self.retrievableness, + snakily: snakily ?? self.snakily, + swot: swot ?? self.swot, + tartlet: tartlet ?? self.tartlet, + thiofuran: thiofuran ?? self.thiofuran, + tracheophone: tracheophone ?? self.tracheophone, + tuglike: tuglike ?? self.tuglike, + unscratchingly: unscratchingly ?? self.unscratchingly + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum AnsarieElement: Codable, Hashable { + case ansarieClass(AnsarieClass) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(AnsarieClass.self) { + self = .ansarieClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(AnsarieElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for AnsarieElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .ansarieClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - AnsarieClass +struct AnsarieClass: Codable, Hashable { + let accension: JSONNull? + let alida: JSONNull? + let asteria: JSONNull? + let beriberic: JSONNull? + let edgebone: JSONNull? + let gastrodialysis: JSONNull? + let geographic: JSONNull? + let ictonyx: JSONNull? + let metrocele: JSONNull? + let misgraft: JSONNull? + let monteith: JSONNull? + let notcher: JSONNull? + let prorestriction: JSONNull? + let ramist: JSONNull? + let throatlet: JSONNull? + let unfair: JSONNull? + let unsynonymous: JSONNull? + let water: JSONNull? + let zestfully: JSONNull? + let zincic: JSONNull? + + enum CodingKeys: String, CodingKey { + case accension = "accension" + case alida = "Alida" + case asteria = "asteria" + case beriberic = "beriberic" + case edgebone = "edgebone" + case gastrodialysis = "gastrodialysis" + case geographic = "geographic" + case ictonyx = "Ictonyx" + case metrocele = "metrocele" + case misgraft = "misgraft" + case monteith = "monteith" + case notcher = "notcher" + case prorestriction = "prorestriction" + case ramist = "Ramist" + case throatlet = "throatlet" + case unfair = "unfair" + case unsynonymous = "unsynonymous" + case water = "water" + case zestfully = "zestfully" + case zincic = "zincic" + } +} + +// MARK: AnsarieClass convenience initializers and mutators + +extension AnsarieClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(AnsarieClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + accension: JSONNull?? = nil, + alida: JSONNull?? = nil, + asteria: JSONNull?? = nil, + beriberic: JSONNull?? = nil, + edgebone: JSONNull?? = nil, + gastrodialysis: JSONNull?? = nil, + geographic: JSONNull?? = nil, + ictonyx: JSONNull?? = nil, + metrocele: JSONNull?? = nil, + misgraft: JSONNull?? = nil, + monteith: JSONNull?? = nil, + notcher: JSONNull?? = nil, + prorestriction: JSONNull?? = nil, + ramist: JSONNull?? = nil, + throatlet: JSONNull?? = nil, + unfair: JSONNull?? = nil, + unsynonymous: JSONNull?? = nil, + water: JSONNull?? = nil, + zestfully: JSONNull?? = nil, + zincic: JSONNull?? = nil + ) -> AnsarieClass { + return AnsarieClass( + accension: accension ?? self.accension, + alida: alida ?? self.alida, + asteria: asteria ?? self.asteria, + beriberic: beriberic ?? self.beriberic, + edgebone: edgebone ?? self.edgebone, + gastrodialysis: gastrodialysis ?? self.gastrodialysis, + geographic: geographic ?? self.geographic, + ictonyx: ictonyx ?? self.ictonyx, + metrocele: metrocele ?? self.metrocele, + misgraft: misgraft ?? self.misgraft, + monteith: monteith ?? self.monteith, + notcher: notcher ?? self.notcher, + prorestriction: prorestriction ?? self.prorestriction, + ramist: ramist ?? self.ramist, + throatlet: throatlet ?? self.throatlet, + unfair: unfair ?? self.unfair, + unsynonymous: unsynonymous ?? self.unsynonymous, + water: water ?? self.water, + zestfully: zestfully ?? self.zestfully, + zincic: zincic ?? self.zincic + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Aphasia: Codable, Hashable { + case integer(Int) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + throw DecodingError.typeMismatch(Aphasia.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Aphasia")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +enum Asprawl: Codable, Hashable { + case double(Double) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Asprawl.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Asprawl")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Bedesman: Codable, Hashable { + case bool(Bool) + case double(Double) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Bedesman.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Bedesman")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Belard: Codable, Hashable { + case double(Double) + case integerArray([Int]) + case rebecca(Rebecca) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Belard.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Belard")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + } + } +} + +enum Bocking: Codable, Hashable { + case bool(Bool) + case integerArray([Int]) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Bocking.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Bocking")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Brawlingly: Codable, Hashable { + case nullArray([JSONNull?]) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Brawlingly.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Brawlingly")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +enum Brookie: Codable, Hashable { + case integerArray([Int]) + case rebecca(Rebecca) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Brookie.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Brookie")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + } + } +} + +enum Bumboatman: Codable, Hashable { + case nullArray([JSONNull?]) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Bumboatman.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Bumboatman")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Calaverite: Codable, Hashable { + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Calaverite.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Calaverite")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Catallactic: Codable, Hashable { + case bool(Bool) + case integerMap([String: Int]) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Catallactic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Catallactic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Cemental: Codable, Hashable { + case double(Double) + case integerArray([Int]) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Cemental.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Cemental")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum ChytridiaceaeElement: Codable, Hashable { + case bool(Bool) + case chytridiaceaeClass(ChytridiaceaeClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(ChytridiaceaeClass.self) { + self = .chytridiaceaeClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(ChytridiaceaeElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for ChytridiaceaeElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .chytridiaceaeClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - ChytridiaceaeClass +struct ChytridiaceaeClass: Codable, Hashable { + let batidaceae: JSONNull? + let brechites: JSONNull? + let codespairer: JSONNull? + let emery: JSONNull? + let enervative: JSONNull? + let excriminate: JSONNull? + let goshenite: JSONNull? + let grime: JSONNull? + let gritten: JSONNull? + let hectorly: JSONNull? + let intermediation: JSONNull? + let meeterly: JSONNull? + let narraganset: JSONNull? + let onymatic: JSONNull? + let paddlecock: JSONNull? + let thana: JSONNull? + let thornily: JSONNull? + let uckia: JSONNull? + let unmettle: JSONNull? + let vorticellid: JSONNull? + + enum CodingKeys: String, CodingKey { + case batidaceae = "Batidaceae" + case brechites = "Brechites" + case codespairer = "codespairer" + case emery = "Emery" + case enervative = "enervative" + case excriminate = "excriminate" + case goshenite = "goshenite" + case grime = "grime" + case gritten = "gritten" + case hectorly = "hectorly" + case intermediation = "intermediation" + case meeterly = "meeterly" + case narraganset = "Narraganset" + case onymatic = "onymatic" + case paddlecock = "paddlecock" + case thana = "thana" + case thornily = "thornily" + case uckia = "uckia" + case unmettle = "unmettle" + case vorticellid = "vorticellid" + } +} + +// MARK: ChytridiaceaeClass convenience initializers and mutators + +extension ChytridiaceaeClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(ChytridiaceaeClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + batidaceae: JSONNull?? = nil, + brechites: JSONNull?? = nil, + codespairer: JSONNull?? = nil, + emery: JSONNull?? = nil, + enervative: JSONNull?? = nil, + excriminate: JSONNull?? = nil, + goshenite: JSONNull?? = nil, + grime: JSONNull?? = nil, + gritten: JSONNull?? = nil, + hectorly: JSONNull?? = nil, + intermediation: JSONNull?? = nil, + meeterly: JSONNull?? = nil, + narraganset: JSONNull?? = nil, + onymatic: JSONNull?? = nil, + paddlecock: JSONNull?? = nil, + thana: JSONNull?? = nil, + thornily: JSONNull?? = nil, + uckia: JSONNull?? = nil, + unmettle: JSONNull?? = nil, + vorticellid: JSONNull?? = nil + ) -> ChytridiaceaeClass { + return ChytridiaceaeClass( + batidaceae: batidaceae ?? self.batidaceae, + brechites: brechites ?? self.brechites, + codespairer: codespairer ?? self.codespairer, + emery: emery ?? self.emery, + enervative: enervative ?? self.enervative, + excriminate: excriminate ?? self.excriminate, + goshenite: goshenite ?? self.goshenite, + grime: grime ?? self.grime, + gritten: gritten ?? self.gritten, + hectorly: hectorly ?? self.hectorly, + intermediation: intermediation ?? self.intermediation, + meeterly: meeterly ?? self.meeterly, + narraganset: narraganset ?? self.narraganset, + onymatic: onymatic ?? self.onymatic, + paddlecock: paddlecock ?? self.paddlecock, + thana: thana ?? self.thana, + thornily: thornily ?? self.thornily, + uckia: uckia ?? self.uckia, + unmettle: unmettle ?? self.unmettle, + vorticellid: vorticellid ?? self.vorticellid + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum DiscordiaElement: Codable, Hashable { + case discordiaClass(DiscordiaClass) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(DiscordiaClass.self) { + self = .discordiaClass(x) + return + } + throw DecodingError.typeMismatch(DiscordiaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for DiscordiaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .discordiaClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - DiscordiaClass +struct DiscordiaClass: Codable, Hashable { + let altaic: Int? + let amoristic: Int? + let blennophthalmia: Int? + let catharticalness: Double? + let chirotherium: Int? + let disciplinability: Int? + let disdiapason: String? + let goofer: Int? + let homocerc: Bool? + let laryngograph: Int? + let leucitis: Int? + let lymphocyst: Int? + let microcosmology: Int? + let nauseation: Int? + let nonbookish: JSONNull? + let patarin: Int? + let preliberal: Int? + let prettifier: Int? + let rangework: Int? + let redient: Int? + let subfusiform: Int? + let suicidical: Int? + let swow: Int? + let wastrel: Int? + let wingle: Int? + + enum CodingKeys: String, CodingKey { + case altaic = "Altaic" + case amoristic = "amoristic" + case blennophthalmia = "blennophthalmia" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disciplinability = "disciplinability" + case disdiapason = "disdiapason" + case goofer = "goofer" + case homocerc = "homocerc" + case laryngograph = "laryngograph" + case leucitis = "leucitis" + case lymphocyst = "lymphocyst" + case microcosmology = "microcosmology" + case nauseation = "nauseation" + case nonbookish = "nonbookish" + case patarin = "Patarin" + case preliberal = "preliberal" + case prettifier = "prettifier" + case rangework = "rangework" + case redient = "redient" + case subfusiform = "subfusiform" + case suicidical = "suicidical" + case swow = "swow" + case wastrel = "wastrel" + case wingle = "wingle" + } +} + +// MARK: DiscordiaClass convenience initializers and mutators + +extension DiscordiaClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(DiscordiaClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + altaic: Int?? = nil, + amoristic: Int?? = nil, + blennophthalmia: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + disciplinability: Int?? = nil, + disdiapason: String?? = nil, + goofer: Int?? = nil, + homocerc: Bool?? = nil, + laryngograph: Int?? = nil, + leucitis: Int?? = nil, + lymphocyst: Int?? = nil, + microcosmology: Int?? = nil, + nauseation: Int?? = nil, + nonbookish: JSONNull?? = nil, + patarin: Int?? = nil, + preliberal: Int?? = nil, + prettifier: Int?? = nil, + rangework: Int?? = nil, + redient: Int?? = nil, + subfusiform: Int?? = nil, + suicidical: Int?? = nil, + swow: Int?? = nil, + wastrel: Int?? = nil, + wingle: Int?? = nil + ) -> DiscordiaClass { + return DiscordiaClass( + altaic: altaic ?? self.altaic, + amoristic: amoristic ?? self.amoristic, + blennophthalmia: blennophthalmia ?? self.blennophthalmia, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disciplinability: disciplinability ?? self.disciplinability, + disdiapason: disdiapason ?? self.disdiapason, + goofer: goofer ?? self.goofer, + homocerc: homocerc ?? self.homocerc, + laryngograph: laryngograph ?? self.laryngograph, + leucitis: leucitis ?? self.leucitis, + lymphocyst: lymphocyst ?? self.lymphocyst, + microcosmology: microcosmology ?? self.microcosmology, + nauseation: nauseation ?? self.nauseation, + nonbookish: nonbookish ?? self.nonbookish, + patarin: patarin ?? self.patarin, + preliberal: preliberal ?? self.preliberal, + prettifier: prettifier ?? self.prettifier, + rangework: rangework ?? self.rangework, + redient: redient ?? self.redient, + subfusiform: subfusiform ?? self.subfusiform, + suicidical: suicidical ?? self.suicidical, + swow: swow ?? self.swow, + wastrel: wastrel ?? self.wastrel, + wingle: wingle ?? self.wingle + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Endomyce: Codable, Hashable { + case integer(Int) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Endomyce.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Endomyce")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Epinephelidae: Codable, Hashable { + case bool(Bool) + case integer(Int) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Epinephelidae.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Epinephelidae")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Eupatorium: Codable, Hashable { + case integerMap([String: Int]) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Eupatorium.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Eupatorium")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum GryphosaurusElement: Codable, Hashable { + case gryphosaurusClass(GryphosaurusClass) + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(GryphosaurusClass.self) { + self = .gryphosaurusClass(x) + return + } + throw DecodingError.typeMismatch(GryphosaurusElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for GryphosaurusElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .gryphosaurusClass(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - GryphosaurusClass +struct GryphosaurusClass: Codable, Hashable { + let amissibility: JSONNull? + let burushaski: JSONNull? + let citronin: JSONNull? + let coplaintiff: JSONNull? + let disquisitionary: JSONNull? + let enoplan: JSONNull? + let faintness: JSONNull? + let hebetomy: JSONNull? + let islandry: JSONNull? + let lameduck: JSONNull? + let overbattle: JSONNull? + let overinterested: JSONNull? + let phrenologic: JSONNull? + let rainband: JSONNull? + let shiningly: JSONNull? + let stamineous: JSONNull? + let subscapularis: JSONNull? + let tahami: JSONNull? + let undaubed: JSONNull? + let underntime: JSONNull? + + enum CodingKeys: String, CodingKey { + case amissibility = "amissibility" + case burushaski = "Burushaski" + case citronin = "citronin" + case coplaintiff = "coplaintiff" + case disquisitionary = "disquisitionary" + case enoplan = "enoplan" + case faintness = "faintness" + case hebetomy = "hebetomy" + case islandry = "islandry" + case lameduck = "lameduck" + case overbattle = "overbattle" + case overinterested = "overinterested" + case phrenologic = "phrenologic" + case rainband = "rainband" + case shiningly = "shiningly" + case stamineous = "stamineous" + case subscapularis = "subscapularis" + case tahami = "Tahami" + case undaubed = "undaubed" + case underntime = "underntime" + } +} + +// MARK: GryphosaurusClass convenience initializers and mutators + +extension GryphosaurusClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(GryphosaurusClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + amissibility: JSONNull?? = nil, + burushaski: JSONNull?? = nil, + citronin: JSONNull?? = nil, + coplaintiff: JSONNull?? = nil, + disquisitionary: JSONNull?? = nil, + enoplan: JSONNull?? = nil, + faintness: JSONNull?? = nil, + hebetomy: JSONNull?? = nil, + islandry: JSONNull?? = nil, + lameduck: JSONNull?? = nil, + overbattle: JSONNull?? = nil, + overinterested: JSONNull?? = nil, + phrenologic: JSONNull?? = nil, + rainband: JSONNull?? = nil, + shiningly: JSONNull?? = nil, + stamineous: JSONNull?? = nil, + subscapularis: JSONNull?? = nil, + tahami: JSONNull?? = nil, + undaubed: JSONNull?? = nil, + underntime: JSONNull?? = nil + ) -> GryphosaurusClass { + return GryphosaurusClass( + amissibility: amissibility ?? self.amissibility, + burushaski: burushaski ?? self.burushaski, + citronin: citronin ?? self.citronin, + coplaintiff: coplaintiff ?? self.coplaintiff, + disquisitionary: disquisitionary ?? self.disquisitionary, + enoplan: enoplan ?? self.enoplan, + faintness: faintness ?? self.faintness, + hebetomy: hebetomy ?? self.hebetomy, + islandry: islandry ?? self.islandry, + lameduck: lameduck ?? self.lameduck, + overbattle: overbattle ?? self.overbattle, + overinterested: overinterested ?? self.overinterested, + phrenologic: phrenologic ?? self.phrenologic, + rainband: rainband ?? self.rainband, + shiningly: shiningly ?? self.shiningly, + stamineous: stamineous ?? self.stamineous, + subscapularis: subscapularis ?? self.subscapularis, + tahami: tahami ?? self.tahami, + undaubed: undaubed ?? self.undaubed, + underntime: underntime ?? self.underntime + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Koryak: Codable, Hashable { + case string(String) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Koryak.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Koryak")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .string(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +enum LaviniaElement: Codable, Hashable { + case laviniaClass(LaviniaClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(LaviniaClass.self) { + self = .laviniaClass(x) + return + } + throw DecodingError.typeMismatch(LaviniaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LaviniaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .laviniaClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - LaviniaClass +struct LaviniaClass: Codable, Hashable { + let agitable: Int? + let asininity: Int? + let benefiter: Int? + let bronzelike: Int? + let catharticalness: Double? + let chirotherium: Int? + let cholesteatomatous: Int? + let deprivement: Int? + let disdiapason: String? + let flippantness: Int? + let fogproof: Int? + let homocerc: Bool? + let merrymeeting: Int? + let nonbookish: JSONNull? + let overcareful: Int? + let panaris: Int? + let preacceptance: Int? + let quinoxaline: Int? + let sig: Int? + let superconfusion: Int? + let tacana: Int? + let tillotter: Int? + let tranquillize: Int? + let unquestionable: Int? + let uproute: Int? + + enum CodingKeys: String, CodingKey { + case agitable = "agitable" + case asininity = "asininity" + case benefiter = "benefiter" + case bronzelike = "bronzelike" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case cholesteatomatous = "cholesteatomatous" + case deprivement = "deprivement" + case disdiapason = "disdiapason" + case flippantness = "flippantness" + case fogproof = "fogproof" + case homocerc = "homocerc" + case merrymeeting = "merrymeeting" + case nonbookish = "nonbookish" + case overcareful = "overcareful" + case panaris = "panaris" + case preacceptance = "preacceptance" + case quinoxaline = "quinoxaline" + case sig = "sig" + case superconfusion = "superconfusion" + case tacana = "Tacana" + case tillotter = "tillotter" + case tranquillize = "tranquillize" + case unquestionable = "unquestionable" + case uproute = "uproute" + } +} + +// MARK: LaviniaClass convenience initializers and mutators + +extension LaviniaClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(LaviniaClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + agitable: Int?? = nil, + asininity: Int?? = nil, + benefiter: Int?? = nil, + bronzelike: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + cholesteatomatous: Int?? = nil, + deprivement: Int?? = nil, + disdiapason: String?? = nil, + flippantness: Int?? = nil, + fogproof: Int?? = nil, + homocerc: Bool?? = nil, + merrymeeting: Int?? = nil, + nonbookish: JSONNull?? = nil, + overcareful: Int?? = nil, + panaris: Int?? = nil, + preacceptance: Int?? = nil, + quinoxaline: Int?? = nil, + sig: Int?? = nil, + superconfusion: Int?? = nil, + tacana: Int?? = nil, + tillotter: Int?? = nil, + tranquillize: Int?? = nil, + unquestionable: Int?? = nil, + uproute: Int?? = nil + ) -> LaviniaClass { + return LaviniaClass( + agitable: agitable ?? self.agitable, + asininity: asininity ?? self.asininity, + benefiter: benefiter ?? self.benefiter, + bronzelike: bronzelike ?? self.bronzelike, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + cholesteatomatous: cholesteatomatous ?? self.cholesteatomatous, + deprivement: deprivement ?? self.deprivement, + disdiapason: disdiapason ?? self.disdiapason, + flippantness: flippantness ?? self.flippantness, + fogproof: fogproof ?? self.fogproof, + homocerc: homocerc ?? self.homocerc, + merrymeeting: merrymeeting ?? self.merrymeeting, + nonbookish: nonbookish ?? self.nonbookish, + overcareful: overcareful ?? self.overcareful, + panaris: panaris ?? self.panaris, + preacceptance: preacceptance ?? self.preacceptance, + quinoxaline: quinoxaline ?? self.quinoxaline, + sig: sig ?? self.sig, + superconfusion: superconfusion ?? self.superconfusion, + tacana: tacana ?? self.tacana, + tillotter: tillotter ?? self.tillotter, + tranquillize: tranquillize ?? self.tranquillize, + unquestionable: unquestionable ?? self.unquestionable, + uproute: uproute ?? self.uproute + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum OskarElement: Codable, Hashable { + case integerArray([Int]) + case oskarClass(OskarClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(OskarClass.self) { + self = .oskarClass(x) + return + } + throw DecodingError.typeMismatch(OskarElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for OskarElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .oskarClass(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - OskarClass +struct OskarClass: Codable, Hashable { + let acrobates: JSONNull? + let beanshooter: JSONNull? + let bearhound: JSONNull? + let cayuga: JSONNull? + let guarneri: JSONNull? + let hypochondriacism: JSONNull? + let indication: JSONNull? + let jaculative: JSONNull? + let nagana: JSONNull? + let netherlandish: JSONNull? + let noctivagous: JSONNull? + let nonphysiological: JSONNull? + let praxis: JSONNull? + let provision: JSONNull? + let subterhuman: JSONNull? + let sunlit: JSONNull? + let syncraniate: JSONNull? + let teachment: JSONNull? + let unmutinous: JSONNull? + let unstoppable: JSONNull? + + enum CodingKeys: String, CodingKey { + case acrobates = "Acrobates" + case beanshooter = "beanshooter" + case bearhound = "bearhound" + case cayuga = "Cayuga" + case guarneri = "guarneri" + case hypochondriacism = "hypochondriacism" + case indication = "indication" + case jaculative = "jaculative" + case nagana = "nagana" + case netherlandish = "Netherlandish" + case noctivagous = "noctivagous" + case nonphysiological = "nonphysiological" + case praxis = "praxis" + case provision = "provision" + case subterhuman = "subterhuman" + case sunlit = "sunlit" + case syncraniate = "syncraniate" + case teachment = "teachment" + case unmutinous = "unmutinous" + case unstoppable = "unstoppable" + } +} + +// MARK: OskarClass convenience initializers and mutators + +extension OskarClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(OskarClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acrobates: JSONNull?? = nil, + beanshooter: JSONNull?? = nil, + bearhound: JSONNull?? = nil, + cayuga: JSONNull?? = nil, + guarneri: JSONNull?? = nil, + hypochondriacism: JSONNull?? = nil, + indication: JSONNull?? = nil, + jaculative: JSONNull?? = nil, + nagana: JSONNull?? = nil, + netherlandish: JSONNull?? = nil, + noctivagous: JSONNull?? = nil, + nonphysiological: JSONNull?? = nil, + praxis: JSONNull?? = nil, + provision: JSONNull?? = nil, + subterhuman: JSONNull?? = nil, + sunlit: JSONNull?? = nil, + syncraniate: JSONNull?? = nil, + teachment: JSONNull?? = nil, + unmutinous: JSONNull?? = nil, + unstoppable: JSONNull?? = nil + ) -> OskarClass { + return OskarClass( + acrobates: acrobates ?? self.acrobates, + beanshooter: beanshooter ?? self.beanshooter, + bearhound: bearhound ?? self.bearhound, + cayuga: cayuga ?? self.cayuga, + guarneri: guarneri ?? self.guarneri, + hypochondriacism: hypochondriacism ?? self.hypochondriacism, + indication: indication ?? self.indication, + jaculative: jaculative ?? self.jaculative, + nagana: nagana ?? self.nagana, + netherlandish: netherlandish ?? self.netherlandish, + noctivagous: noctivagous ?? self.noctivagous, + nonphysiological: nonphysiological ?? self.nonphysiological, + praxis: praxis ?? self.praxis, + provision: provision ?? self.provision, + subterhuman: subterhuman ?? self.subterhuman, + sunlit: sunlit ?? self.sunlit, + syncraniate: syncraniate ?? self.syncraniate, + teachment: teachment ?? self.teachment, + unmutinous: unmutinous ?? self.unmutinous, + unstoppable: unstoppable ?? self.unstoppable + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum RebeccaElement: Codable, Hashable { + case integer(Int) + case rebecca(Rebecca) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(RebeccaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for RebeccaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Rhomboganoidei: Codable, Hashable { + case integerArray([Int]) + case rebecca(Rebecca) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Rhomboganoidei.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Rhomboganoidei")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Ruellia: Codable, Hashable { + case bool(Bool) + case rebecca(Rebecca) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(Rebecca.self) { + self = .rebecca(x) + return + } + throw DecodingError.typeMismatch(Ruellia.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Ruellia")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .rebecca(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum School: Codable, Hashable { + case integer(Int) + case integerMap([String: Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(School.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for School")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Shakespearolater: Codable, Hashable { + case double(Double) + case integerArray([Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Shakespearolater.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Shakespearolater")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - Helper functions for creating encoders and decoders + +func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder +} + +func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// MARK: - Encode/decode helpers + +class JSONNull: Codable, Hashable { + + public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool { + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(0) + } + + public init() {} + + public required init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if !container.decodeNil() { + throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull")) + } + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + try container.encodeNil() + } +} diff --git a/head/swift/test/inputs/json/priority/combinations3.json/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift b/head/swift/test/inputs/json/priority/combinations3.json/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift new file mode 100644 index 0000000..c8e32ee --- /dev/null +++ b/head/swift/test/inputs/json/priority/combinations3.json/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift @@ -0,0 +1,3534 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +import Foundation + +// MARK: - TopLevel +final class TopLevel: Codable { + let juror: [JurorElement] + let kongoni: [Kongoni] + let ladronism: [LadronismElement] + let landlubberly: [LandlubberlyElement] + let listener: [Listener] + let lupus: [LupusElement] + let maslin: [Maslin] + let monazite: [MonaziteElement] + let monoliteral: [Monoliteral] + let monotheistically: [MonotheisticallyElement] + let montage: [Montage] + let moralness: [Moralness] + let mowra: [MonaziteClass?] + let mulishly: [Mulishly] + let myoscope: [Myoscope] + let nach: [[Int?]?] + let neuromastic: [Neuromastic] + let noncontributing: [Noncontributing] + let nonnervous: [Nonnervous] + let nonvaluation: [Nonvaluation] + let occupationalist: [OccupationalistElement] + let outrival: [OutrivalElement] + let paleographically: [Paleographically] + let pamphletwise: [Pamphletwise] + let pediatrics: [Pediatric] + let perceptive: [Bool] + let piaculum: [PiaculumElement] + let piccadilly: [Piccadilly] + let piffler: [Piffler] + let pithful: [Pithful] + let placuntitis: [Placuntiti] + let plectopterous: [Plectopterous] + let pneumocele: [Pneumocele?] + let poliorcetic: [Poliorcetic] + let poormaster: [Poormaster] + let potwhisky: [PotwhiskyElement] + let practicalizer: [Practicalizer] + let prefreshman: [PrefreshmanElement] + let prehensility: [Prehensility] + let prevoidance: [Prevoidance] + let probant: [[String: Int?]] + let protext: [Protext] + + enum CodingKeys: String, CodingKey { + case juror = "juror" + case kongoni = "kongoni" + case ladronism = "ladronism" + case landlubberly = "landlubberly" + case listener = "listener" + case lupus = "lupus" + case maslin = "maslin" + case monazite = "monazite" + case monoliteral = "monoliteral" + case monotheistically = "monotheistically" + case montage = "montage" + case moralness = "moralness" + case mowra = "mowra" + case mulishly = "mulishly" + case myoscope = "myoscope" + case nach = "nach" + case neuromastic = "neuromastic" + case noncontributing = "noncontributing" + case nonnervous = "nonnervous" + case nonvaluation = "nonvaluation" + case occupationalist = "occupationalist" + case outrival = "outrival" + case paleographically = "paleographically" + case pamphletwise = "pamphletwise" + case pediatrics = "pediatrics" + case perceptive = "perceptive" + case piaculum = "piaculum" + case piccadilly = "piccadilly" + case piffler = "piffler" + case pithful = "pithful" + case placuntitis = "placuntitis" + case plectopterous = "plectopterous" + case pneumocele = "pneumocele" + case poliorcetic = "poliorcetic" + case poormaster = "poormaster" + case potwhisky = "potwhisky" + case practicalizer = "practicalizer" + case prefreshman = "prefreshman" + case prehensility = "prehensility" + case prevoidance = "prevoidance" + case probant = "probant" + case protext = "protext" + } + + init(juror: [JurorElement], kongoni: [Kongoni], ladronism: [LadronismElement], landlubberly: [LandlubberlyElement], listener: [Listener], lupus: [LupusElement], maslin: [Maslin], monazite: [MonaziteElement], monoliteral: [Monoliteral], monotheistically: [MonotheisticallyElement], montage: [Montage], moralness: [Moralness], mowra: [MonaziteClass?], mulishly: [Mulishly], myoscope: [Myoscope], nach: [[Int?]?], neuromastic: [Neuromastic], noncontributing: [Noncontributing], nonnervous: [Nonnervous], nonvaluation: [Nonvaluation], occupationalist: [OccupationalistElement], outrival: [OutrivalElement], paleographically: [Paleographically], pamphletwise: [Pamphletwise], pediatrics: [Pediatric], perceptive: [Bool], piaculum: [PiaculumElement], piccadilly: [Piccadilly], piffler: [Piffler], pithful: [Pithful], placuntitis: [Placuntiti], plectopterous: [Plectopterous], pneumocele: [Pneumocele?], poliorcetic: [Poliorcetic], poormaster: [Poormaster], potwhisky: [PotwhiskyElement], practicalizer: [Practicalizer], prefreshman: [PrefreshmanElement], prehensility: [Prehensility], prevoidance: [Prevoidance], probant: [[String: Int?]], protext: [Protext]) { + self.juror = juror + self.kongoni = kongoni + self.ladronism = ladronism + self.landlubberly = landlubberly + self.listener = listener + self.lupus = lupus + self.maslin = maslin + self.monazite = monazite + self.monoliteral = monoliteral + self.monotheistically = monotheistically + self.montage = montage + self.moralness = moralness + self.mowra = mowra + self.mulishly = mulishly + self.myoscope = myoscope + self.nach = nach + self.neuromastic = neuromastic + self.noncontributing = noncontributing + self.nonnervous = nonnervous + self.nonvaluation = nonvaluation + self.occupationalist = occupationalist + self.outrival = outrival + self.paleographically = paleographically + self.pamphletwise = pamphletwise + self.pediatrics = pediatrics + self.perceptive = perceptive + self.piaculum = piaculum + self.piccadilly = piccadilly + self.piffler = piffler + self.pithful = pithful + self.placuntitis = placuntitis + self.plectopterous = plectopterous + self.pneumocele = pneumocele + self.poliorcetic = poliorcetic + self.poormaster = poormaster + self.potwhisky = potwhisky + self.practicalizer = practicalizer + self.prefreshman = prefreshman + self.prehensility = prehensility + self.prevoidance = prevoidance + self.probant = probant + self.protext = protext + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(TopLevel.self, from: data) + self.init(juror: me.juror, kongoni: me.kongoni, ladronism: me.ladronism, landlubberly: me.landlubberly, listener: me.listener, lupus: me.lupus, maslin: me.maslin, monazite: me.monazite, monoliteral: me.monoliteral, monotheistically: me.monotheistically, montage: me.montage, moralness: me.moralness, mowra: me.mowra, mulishly: me.mulishly, myoscope: me.myoscope, nach: me.nach, neuromastic: me.neuromastic, noncontributing: me.noncontributing, nonnervous: me.nonnervous, nonvaluation: me.nonvaluation, occupationalist: me.occupationalist, outrival: me.outrival, paleographically: me.paleographically, pamphletwise: me.pamphletwise, pediatrics: me.pediatrics, perceptive: me.perceptive, piaculum: me.piaculum, piccadilly: me.piccadilly, piffler: me.piffler, pithful: me.pithful, placuntitis: me.placuntitis, plectopterous: me.plectopterous, pneumocele: me.pneumocele, poliorcetic: me.poliorcetic, poormaster: me.poormaster, potwhisky: me.potwhisky, practicalizer: me.practicalizer, prefreshman: me.prefreshman, prehensility: me.prehensility, prevoidance: me.prevoidance, probant: me.probant, protext: me.protext) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + juror: [JurorElement]? = nil, + kongoni: [Kongoni]? = nil, + ladronism: [LadronismElement]? = nil, + landlubberly: [LandlubberlyElement]? = nil, + listener: [Listener]? = nil, + lupus: [LupusElement]? = nil, + maslin: [Maslin]? = nil, + monazite: [MonaziteElement]? = nil, + monoliteral: [Monoliteral]? = nil, + monotheistically: [MonotheisticallyElement]? = nil, + montage: [Montage]? = nil, + moralness: [Moralness]? = nil, + mowra: [MonaziteClass?]? = nil, + mulishly: [Mulishly]? = nil, + myoscope: [Myoscope]? = nil, + nach: [[Int?]?]? = nil, + neuromastic: [Neuromastic]? = nil, + noncontributing: [Noncontributing]? = nil, + nonnervous: [Nonnervous]? = nil, + nonvaluation: [Nonvaluation]? = nil, + occupationalist: [OccupationalistElement]? = nil, + outrival: [OutrivalElement]? = nil, + paleographically: [Paleographically]? = nil, + pamphletwise: [Pamphletwise]? = nil, + pediatrics: [Pediatric]? = nil, + perceptive: [Bool]? = nil, + piaculum: [PiaculumElement]? = nil, + piccadilly: [Piccadilly]? = nil, + piffler: [Piffler]? = nil, + pithful: [Pithful]? = nil, + placuntitis: [Placuntiti]? = nil, + plectopterous: [Plectopterous]? = nil, + pneumocele: [Pneumocele?]? = nil, + poliorcetic: [Poliorcetic]? = nil, + poormaster: [Poormaster]? = nil, + potwhisky: [PotwhiskyElement]? = nil, + practicalizer: [Practicalizer]? = nil, + prefreshman: [PrefreshmanElement]? = nil, + prehensility: [Prehensility]? = nil, + prevoidance: [Prevoidance]? = nil, + probant: [[String: Int?]]? = nil, + protext: [Protext]? = nil + ) -> TopLevel { + return TopLevel( + juror: juror ?? self.juror, + kongoni: kongoni ?? self.kongoni, + ladronism: ladronism ?? self.ladronism, + landlubberly: landlubberly ?? self.landlubberly, + listener: listener ?? self.listener, + lupus: lupus ?? self.lupus, + maslin: maslin ?? self.maslin, + monazite: monazite ?? self.monazite, + monoliteral: monoliteral ?? self.monoliteral, + monotheistically: monotheistically ?? self.monotheistically, + montage: montage ?? self.montage, + moralness: moralness ?? self.moralness, + mowra: mowra ?? self.mowra, + mulishly: mulishly ?? self.mulishly, + myoscope: myoscope ?? self.myoscope, + nach: nach ?? self.nach, + neuromastic: neuromastic ?? self.neuromastic, + noncontributing: noncontributing ?? self.noncontributing, + nonnervous: nonnervous ?? self.nonnervous, + nonvaluation: nonvaluation ?? self.nonvaluation, + occupationalist: occupationalist ?? self.occupationalist, + outrival: outrival ?? self.outrival, + paleographically: paleographically ?? self.paleographically, + pamphletwise: pamphletwise ?? self.pamphletwise, + pediatrics: pediatrics ?? self.pediatrics, + perceptive: perceptive ?? self.perceptive, + piaculum: piaculum ?? self.piaculum, + piccadilly: piccadilly ?? self.piccadilly, + piffler: piffler ?? self.piffler, + pithful: pithful ?? self.pithful, + placuntitis: placuntitis ?? self.placuntitis, + plectopterous: plectopterous ?? self.plectopterous, + pneumocele: pneumocele ?? self.pneumocele, + poliorcetic: poliorcetic ?? self.poliorcetic, + poormaster: poormaster ?? self.poormaster, + potwhisky: potwhisky ?? self.potwhisky, + practicalizer: practicalizer ?? self.practicalizer, + prefreshman: prefreshman ?? self.prefreshman, + prehensility: prehensility ?? self.prehensility, + prevoidance: prevoidance ?? self.prevoidance, + probant: probant ?? self.probant, + protext: protext ?? self.protext + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum JurorElement: Codable { + case bool(Bool) + case jurorClass(JurorClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(JurorClass.self) { + self = .jurorClass(x) + return + } + throw DecodingError.typeMismatch(JurorElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JurorElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .jurorClass(let x): + try container.encode(x) + } + } +} + +// MARK: - JurorClass +final class JurorClass: Codable { + let adipsy: JSONNull? + let auxiliator: JSONNull? + let benda: JSONNull? + let benjamin: JSONNull? + let brandling: JSONNull? + let epicurishly: JSONNull? + let eremochaetous: JSONNull? + let marten: JSONNull? + let monocline: JSONNull? + let olea: JSONNull? + let palgat: JSONNull? + let pennyworth: JSONNull? + let pioury: JSONNull? + let pragmatistic: JSONNull? + let stylelessness: JSONNull? + let systematical: JSONNull? + let thready: JSONNull? + let uncontemporary: JSONNull? + let uncouched: JSONNull? + let uninhabitedness: JSONNull? + + enum CodingKeys: String, CodingKey { + case adipsy = "adipsy" + case auxiliator = "auxiliator" + case benda = "benda" + case benjamin = "benjamin" + case brandling = "brandling" + case epicurishly = "epicurishly" + case eremochaetous = "eremochaetous" + case marten = "marten" + case monocline = "monocline" + case olea = "Olea" + case palgat = "palgat" + case pennyworth = "pennyworth" + case pioury = "pioury" + case pragmatistic = "pragmatistic" + case stylelessness = "stylelessness" + case systematical = "systematical" + case thready = "thready" + case uncontemporary = "uncontemporary" + case uncouched = "uncouched" + case uninhabitedness = "uninhabitedness" + } + + init(adipsy: JSONNull?, auxiliator: JSONNull?, benda: JSONNull?, benjamin: JSONNull?, brandling: JSONNull?, epicurishly: JSONNull?, eremochaetous: JSONNull?, marten: JSONNull?, monocline: JSONNull?, olea: JSONNull?, palgat: JSONNull?, pennyworth: JSONNull?, pioury: JSONNull?, pragmatistic: JSONNull?, stylelessness: JSONNull?, systematical: JSONNull?, thready: JSONNull?, uncontemporary: JSONNull?, uncouched: JSONNull?, uninhabitedness: JSONNull?) { + self.adipsy = adipsy + self.auxiliator = auxiliator + self.benda = benda + self.benjamin = benjamin + self.brandling = brandling + self.epicurishly = epicurishly + self.eremochaetous = eremochaetous + self.marten = marten + self.monocline = monocline + self.olea = olea + self.palgat = palgat + self.pennyworth = pennyworth + self.pioury = pioury + self.pragmatistic = pragmatistic + self.stylelessness = stylelessness + self.systematical = systematical + self.thready = thready + self.uncontemporary = uncontemporary + self.uncouched = uncouched + self.uninhabitedness = uninhabitedness + } +} + +// MARK: JurorClass convenience initializers and mutators + +extension JurorClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(JurorClass.self, from: data) + self.init(adipsy: me.adipsy, auxiliator: me.auxiliator, benda: me.benda, benjamin: me.benjamin, brandling: me.brandling, epicurishly: me.epicurishly, eremochaetous: me.eremochaetous, marten: me.marten, monocline: me.monocline, olea: me.olea, palgat: me.palgat, pennyworth: me.pennyworth, pioury: me.pioury, pragmatistic: me.pragmatistic, stylelessness: me.stylelessness, systematical: me.systematical, thready: me.thready, uncontemporary: me.uncontemporary, uncouched: me.uncouched, uninhabitedness: me.uninhabitedness) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + adipsy: JSONNull?? = nil, + auxiliator: JSONNull?? = nil, + benda: JSONNull?? = nil, + benjamin: JSONNull?? = nil, + brandling: JSONNull?? = nil, + epicurishly: JSONNull?? = nil, + eremochaetous: JSONNull?? = nil, + marten: JSONNull?? = nil, + monocline: JSONNull?? = nil, + olea: JSONNull?? = nil, + palgat: JSONNull?? = nil, + pennyworth: JSONNull?? = nil, + pioury: JSONNull?? = nil, + pragmatistic: JSONNull?? = nil, + stylelessness: JSONNull?? = nil, + systematical: JSONNull?? = nil, + thready: JSONNull?? = nil, + uncontemporary: JSONNull?? = nil, + uncouched: JSONNull?? = nil, + uninhabitedness: JSONNull?? = nil + ) -> JurorClass { + return JurorClass( + adipsy: adipsy ?? self.adipsy, + auxiliator: auxiliator ?? self.auxiliator, + benda: benda ?? self.benda, + benjamin: benjamin ?? self.benjamin, + brandling: brandling ?? self.brandling, + epicurishly: epicurishly ?? self.epicurishly, + eremochaetous: eremochaetous ?? self.eremochaetous, + marten: marten ?? self.marten, + monocline: monocline ?? self.monocline, + olea: olea ?? self.olea, + palgat: palgat ?? self.palgat, + pennyworth: pennyworth ?? self.pennyworth, + pioury: pioury ?? self.pioury, + pragmatistic: pragmatistic ?? self.pragmatistic, + stylelessness: stylelessness ?? self.stylelessness, + systematical: systematical ?? self.systematical, + thready: thready ?? self.thready, + uncontemporary: uncontemporary ?? self.uncontemporary, + uncouched: uncouched ?? self.uncouched, + uninhabitedness: uninhabitedness ?? self.uninhabitedness + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Kongoni: Codable { + case integerArray([Int]) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Kongoni.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Kongoni")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum LadronismElement: Codable { + case double(Double) + case ladronismClass(LadronismClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(LadronismClass.self) { + self = .ladronismClass(x) + return + } + throw DecodingError.typeMismatch(LadronismElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LadronismElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .ladronismClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - LadronismClass +final class LadronismClass: Codable { + let acclaimer: JSONNull? + let achree: JSONNull? + let base: JSONNull? + let conundrumize: JSONNull? + let degerminator: JSONNull? + let describable: JSONNull? + let exasperatedly: JSONNull? + let heroine: JSONNull? + let indazin: JSONNull? + let luteous: JSONNull? + let papular: JSONNull? + let pritch: JSONNull? + let prodenia: JSONNull? + let seege: JSONNull? + let shopgirl: JSONNull? + let tragedietta: JSONNull? + let unsparse: JSONNull? + let uplook: JSONNull? + let vermiformis: JSONNull? + let whafabout: JSONNull? + + enum CodingKeys: String, CodingKey { + case acclaimer = "acclaimer" + case achree = "achree" + case base = "base" + case conundrumize = "conundrumize" + case degerminator = "degerminator" + case describable = "describable" + case exasperatedly = "exasperatedly" + case heroine = "heroine" + case indazin = "indazin" + case luteous = "luteous" + case papular = "papular" + case pritch = "pritch" + case prodenia = "Prodenia" + case seege = "seege" + case shopgirl = "shopgirl" + case tragedietta = "tragedietta" + case unsparse = "unsparse" + case uplook = "uplook" + case vermiformis = "vermiformis" + case whafabout = "whafabout" + } + + init(acclaimer: JSONNull?, achree: JSONNull?, base: JSONNull?, conundrumize: JSONNull?, degerminator: JSONNull?, describable: JSONNull?, exasperatedly: JSONNull?, heroine: JSONNull?, indazin: JSONNull?, luteous: JSONNull?, papular: JSONNull?, pritch: JSONNull?, prodenia: JSONNull?, seege: JSONNull?, shopgirl: JSONNull?, tragedietta: JSONNull?, unsparse: JSONNull?, uplook: JSONNull?, vermiformis: JSONNull?, whafabout: JSONNull?) { + self.acclaimer = acclaimer + self.achree = achree + self.base = base + self.conundrumize = conundrumize + self.degerminator = degerminator + self.describable = describable + self.exasperatedly = exasperatedly + self.heroine = heroine + self.indazin = indazin + self.luteous = luteous + self.papular = papular + self.pritch = pritch + self.prodenia = prodenia + self.seege = seege + self.shopgirl = shopgirl + self.tragedietta = tragedietta + self.unsparse = unsparse + self.uplook = uplook + self.vermiformis = vermiformis + self.whafabout = whafabout + } +} + +// MARK: LadronismClass convenience initializers and mutators + +extension LadronismClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(LadronismClass.self, from: data) + self.init(acclaimer: me.acclaimer, achree: me.achree, base: me.base, conundrumize: me.conundrumize, degerminator: me.degerminator, describable: me.describable, exasperatedly: me.exasperatedly, heroine: me.heroine, indazin: me.indazin, luteous: me.luteous, papular: me.papular, pritch: me.pritch, prodenia: me.prodenia, seege: me.seege, shopgirl: me.shopgirl, tragedietta: me.tragedietta, unsparse: me.unsparse, uplook: me.uplook, vermiformis: me.vermiformis, whafabout: me.whafabout) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acclaimer: JSONNull?? = nil, + achree: JSONNull?? = nil, + base: JSONNull?? = nil, + conundrumize: JSONNull?? = nil, + degerminator: JSONNull?? = nil, + describable: JSONNull?? = nil, + exasperatedly: JSONNull?? = nil, + heroine: JSONNull?? = nil, + indazin: JSONNull?? = nil, + luteous: JSONNull?? = nil, + papular: JSONNull?? = nil, + pritch: JSONNull?? = nil, + prodenia: JSONNull?? = nil, + seege: JSONNull?? = nil, + shopgirl: JSONNull?? = nil, + tragedietta: JSONNull?? = nil, + unsparse: JSONNull?? = nil, + uplook: JSONNull?? = nil, + vermiformis: JSONNull?? = nil, + whafabout: JSONNull?? = nil + ) -> LadronismClass { + return LadronismClass( + acclaimer: acclaimer ?? self.acclaimer, + achree: achree ?? self.achree, + base: base ?? self.base, + conundrumize: conundrumize ?? self.conundrumize, + degerminator: degerminator ?? self.degerminator, + describable: describable ?? self.describable, + exasperatedly: exasperatedly ?? self.exasperatedly, + heroine: heroine ?? self.heroine, + indazin: indazin ?? self.indazin, + luteous: luteous ?? self.luteous, + papular: papular ?? self.papular, + pritch: pritch ?? self.pritch, + prodenia: prodenia ?? self.prodenia, + seege: seege ?? self.seege, + shopgirl: shopgirl ?? self.shopgirl, + tragedietta: tragedietta ?? self.tragedietta, + unsparse: unsparse ?? self.unsparse, + uplook: uplook ?? self.uplook, + vermiformis: vermiformis ?? self.vermiformis, + whafabout: whafabout ?? self.whafabout + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum LandlubberlyElement: Codable { + case bool(Bool) + case integer(Int) + case landlubberlyClass(LandlubberlyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(LandlubberlyClass.self) { + self = .landlubberlyClass(x) + return + } + throw DecodingError.typeMismatch(LandlubberlyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LandlubberlyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .landlubberlyClass(let x): + try container.encode(x) + } + } +} + +// MARK: - LandlubberlyClass +final class LandlubberlyClass: Codable { + let acropoleis: JSONNull? + let aminate: JSONNull? + let amyraldism: JSONNull? + let bipenniform: JSONNull? + let bugre: JSONNull? + let calycule: JSONNull? + let caoutchouc: JSONNull? + let disprover: JSONNull? + let fitroot: JSONNull? + let fulgently: JSONNull? + let kickup: JSONNull? + let laevoversion: JSONNull? + let moter: JSONNull? + let objectivity: JSONNull? + let posterity: JSONNull? + let postnuptial: JSONNull? + let precedentary: JSONNull? + let saddling: JSONNull? + let subcurrent: JSONNull? + let unrecriminative: JSONNull? + + enum CodingKeys: String, CodingKey { + case acropoleis = "acropoleis" + case aminate = "aminate" + case amyraldism = "Amyraldism" + case bipenniform = "bipenniform" + case bugre = "bugre" + case calycule = "calycule" + case caoutchouc = "caoutchouc" + case disprover = "disprover" + case fitroot = "fitroot" + case fulgently = "fulgently" + case kickup = "kickup" + case laevoversion = "laevoversion" + case moter = "moter" + case objectivity = "objectivity" + case posterity = "posterity" + case postnuptial = "postnuptial" + case precedentary = "precedentary" + case saddling = "saddling" + case subcurrent = "subcurrent" + case unrecriminative = "unrecriminative" + } + + init(acropoleis: JSONNull?, aminate: JSONNull?, amyraldism: JSONNull?, bipenniform: JSONNull?, bugre: JSONNull?, calycule: JSONNull?, caoutchouc: JSONNull?, disprover: JSONNull?, fitroot: JSONNull?, fulgently: JSONNull?, kickup: JSONNull?, laevoversion: JSONNull?, moter: JSONNull?, objectivity: JSONNull?, posterity: JSONNull?, postnuptial: JSONNull?, precedentary: JSONNull?, saddling: JSONNull?, subcurrent: JSONNull?, unrecriminative: JSONNull?) { + self.acropoleis = acropoleis + self.aminate = aminate + self.amyraldism = amyraldism + self.bipenniform = bipenniform + self.bugre = bugre + self.calycule = calycule + self.caoutchouc = caoutchouc + self.disprover = disprover + self.fitroot = fitroot + self.fulgently = fulgently + self.kickup = kickup + self.laevoversion = laevoversion + self.moter = moter + self.objectivity = objectivity + self.posterity = posterity + self.postnuptial = postnuptial + self.precedentary = precedentary + self.saddling = saddling + self.subcurrent = subcurrent + self.unrecriminative = unrecriminative + } +} + +// MARK: LandlubberlyClass convenience initializers and mutators + +extension LandlubberlyClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(LandlubberlyClass.self, from: data) + self.init(acropoleis: me.acropoleis, aminate: me.aminate, amyraldism: me.amyraldism, bipenniform: me.bipenniform, bugre: me.bugre, calycule: me.calycule, caoutchouc: me.caoutchouc, disprover: me.disprover, fitroot: me.fitroot, fulgently: me.fulgently, kickup: me.kickup, laevoversion: me.laevoversion, moter: me.moter, objectivity: me.objectivity, posterity: me.posterity, postnuptial: me.postnuptial, precedentary: me.precedentary, saddling: me.saddling, subcurrent: me.subcurrent, unrecriminative: me.unrecriminative) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acropoleis: JSONNull?? = nil, + aminate: JSONNull?? = nil, + amyraldism: JSONNull?? = nil, + bipenniform: JSONNull?? = nil, + bugre: JSONNull?? = nil, + calycule: JSONNull?? = nil, + caoutchouc: JSONNull?? = nil, + disprover: JSONNull?? = nil, + fitroot: JSONNull?? = nil, + fulgently: JSONNull?? = nil, + kickup: JSONNull?? = nil, + laevoversion: JSONNull?? = nil, + moter: JSONNull?? = nil, + objectivity: JSONNull?? = nil, + posterity: JSONNull?? = nil, + postnuptial: JSONNull?? = nil, + precedentary: JSONNull?? = nil, + saddling: JSONNull?? = nil, + subcurrent: JSONNull?? = nil, + unrecriminative: JSONNull?? = nil + ) -> LandlubberlyClass { + return LandlubberlyClass( + acropoleis: acropoleis ?? self.acropoleis, + aminate: aminate ?? self.aminate, + amyraldism: amyraldism ?? self.amyraldism, + bipenniform: bipenniform ?? self.bipenniform, + bugre: bugre ?? self.bugre, + calycule: calycule ?? self.calycule, + caoutchouc: caoutchouc ?? self.caoutchouc, + disprover: disprover ?? self.disprover, + fitroot: fitroot ?? self.fitroot, + fulgently: fulgently ?? self.fulgently, + kickup: kickup ?? self.kickup, + laevoversion: laevoversion ?? self.laevoversion, + moter: moter ?? self.moter, + objectivity: objectivity ?? self.objectivity, + posterity: posterity ?? self.posterity, + postnuptial: postnuptial ?? self.postnuptial, + precedentary: precedentary ?? self.precedentary, + saddling: saddling ?? self.saddling, + subcurrent: subcurrent ?? self.subcurrent, + unrecriminative: unrecriminative ?? self.unrecriminative + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Listener: Codable { + case integer(Int) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + throw DecodingError.typeMismatch(Listener.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Listener")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum LupusElement: Codable { + case integer(Int) + case lupusClass(LupusClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(LupusClass.self) { + self = .lupusClass(x) + return + } + throw DecodingError.typeMismatch(LupusElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LupusElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .lupusClass(let x): + try container.encode(x) + } + } +} + +// MARK: - LupusClass +final class LupusClass: Codable { + let catharticalness: Double? + let chirotherium: Int? + let chlorioninae: Int? + let corvinae: Int? + let crassina: Int? + let disdiapason: String? + let exiguity: Int? + let farcist: Int? + let holographical: Int? + let homocerc: Bool? + let ichthyophagan: Int? + let implacable: Int? + let nonbookish: JSONNull? + let outshiner: Int? + let overweather: Int? + let protonegroid: Int? + let shallowish: Int? + let snoke: Int? + let snout: Int? + let surveillance: Int? + let threshingtime: Int? + let thysanocarpus: Int? + let unsignificantly: Int? + let unsnap: Int? + let vendible: Int? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case chlorioninae = "Chlorioninae" + case corvinae = "Corvinae" + case crassina = "Crassina" + case disdiapason = "disdiapason" + case exiguity = "exiguity" + case farcist = "farcist" + case holographical = "holographical" + case homocerc = "homocerc" + case ichthyophagan = "ichthyophagan" + case implacable = "implacable" + case nonbookish = "nonbookish" + case outshiner = "outshiner" + case overweather = "overweather" + case protonegroid = "protonegroid" + case shallowish = "shallowish" + case snoke = "snoke" + case snout = "snout" + case surveillance = "surveillance" + case threshingtime = "threshingtime" + case thysanocarpus = "Thysanocarpus" + case unsignificantly = "unsignificantly" + case unsnap = "unsnap" + case vendible = "vendible" + } + + init(catharticalness: Double?, chirotherium: Int?, chlorioninae: Int?, corvinae: Int?, crassina: Int?, disdiapason: String?, exiguity: Int?, farcist: Int?, holographical: Int?, homocerc: Bool?, ichthyophagan: Int?, implacable: Int?, nonbookish: JSONNull?, outshiner: Int?, overweather: Int?, protonegroid: Int?, shallowish: Int?, snoke: Int?, snout: Int?, surveillance: Int?, threshingtime: Int?, thysanocarpus: Int?, unsignificantly: Int?, unsnap: Int?, vendible: Int?) { + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.chlorioninae = chlorioninae + self.corvinae = corvinae + self.crassina = crassina + self.disdiapason = disdiapason + self.exiguity = exiguity + self.farcist = farcist + self.holographical = holographical + self.homocerc = homocerc + self.ichthyophagan = ichthyophagan + self.implacable = implacable + self.nonbookish = nonbookish + self.outshiner = outshiner + self.overweather = overweather + self.protonegroid = protonegroid + self.shallowish = shallowish + self.snoke = snoke + self.snout = snout + self.surveillance = surveillance + self.threshingtime = threshingtime + self.thysanocarpus = thysanocarpus + self.unsignificantly = unsignificantly + self.unsnap = unsnap + self.vendible = vendible + } +} + +// MARK: LupusClass convenience initializers and mutators + +extension LupusClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(LupusClass.self, from: data) + self.init(catharticalness: me.catharticalness, chirotherium: me.chirotherium, chlorioninae: me.chlorioninae, corvinae: me.corvinae, crassina: me.crassina, disdiapason: me.disdiapason, exiguity: me.exiguity, farcist: me.farcist, holographical: me.holographical, homocerc: me.homocerc, ichthyophagan: me.ichthyophagan, implacable: me.implacable, nonbookish: me.nonbookish, outshiner: me.outshiner, overweather: me.overweather, protonegroid: me.protonegroid, shallowish: me.shallowish, snoke: me.snoke, snout: me.snout, surveillance: me.surveillance, threshingtime: me.threshingtime, thysanocarpus: me.thysanocarpus, unsignificantly: me.unsignificantly, unsnap: me.unsnap, vendible: me.vendible) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + chlorioninae: Int?? = nil, + corvinae: Int?? = nil, + crassina: Int?? = nil, + disdiapason: String?? = nil, + exiguity: Int?? = nil, + farcist: Int?? = nil, + holographical: Int?? = nil, + homocerc: Bool?? = nil, + ichthyophagan: Int?? = nil, + implacable: Int?? = nil, + nonbookish: JSONNull?? = nil, + outshiner: Int?? = nil, + overweather: Int?? = nil, + protonegroid: Int?? = nil, + shallowish: Int?? = nil, + snoke: Int?? = nil, + snout: Int?? = nil, + surveillance: Int?? = nil, + threshingtime: Int?? = nil, + thysanocarpus: Int?? = nil, + unsignificantly: Int?? = nil, + unsnap: Int?? = nil, + vendible: Int?? = nil + ) -> LupusClass { + return LupusClass( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + chlorioninae: chlorioninae ?? self.chlorioninae, + corvinae: corvinae ?? self.corvinae, + crassina: crassina ?? self.crassina, + disdiapason: disdiapason ?? self.disdiapason, + exiguity: exiguity ?? self.exiguity, + farcist: farcist ?? self.farcist, + holographical: holographical ?? self.holographical, + homocerc: homocerc ?? self.homocerc, + ichthyophagan: ichthyophagan ?? self.ichthyophagan, + implacable: implacable ?? self.implacable, + nonbookish: nonbookish ?? self.nonbookish, + outshiner: outshiner ?? self.outshiner, + overweather: overweather ?? self.overweather, + protonegroid: protonegroid ?? self.protonegroid, + shallowish: shallowish ?? self.shallowish, + snoke: snoke ?? self.snoke, + snout: snout ?? self.snout, + surveillance: surveillance ?? self.surveillance, + threshingtime: threshingtime ?? self.threshingtime, + thysanocarpus: thysanocarpus ?? self.thysanocarpus, + unsignificantly: unsignificantly ?? self.unsignificantly, + unsnap: unsnap ?? self.unsnap, + vendible: vendible ?? self.vendible + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Maslin +final class Maslin: Codable { + let alicant: Int? + let antiatonement: JSONNull? + let anticorrosive: Int? + let aphidozer: JSONNull? + let bakuninist: JSONNull? + let be: Int? + let catharticalness: Double? + let chirotherium: Int? + let chub: Int? + let cuprosilicon: Int? + let curtailedly: Int? + let dellenite: Int? + let dimitry: Int? + let disdiapason: String? + let edifying: JSONNull? + let ethmoiditis: Int? + let gastralgy: JSONNull? + let goatherd: Int? + let hammerdress: Int? + let hangfire: JSONNull? + let homocerc: Bool? + let lacunosity: Int? + let longiloquence: JSONNull? + let mameliere: Int? + let motherless: JSONNull? + let nonbookish: JSONNull? + let noncorrodible: JSONNull? + let nonsensicality: JSONNull? + let oafishly: Int? + let pfund: JSONNull? + let preadvisory: JSONNull? + let retroflexed: JSONNull? + let saccharulmic: Int? + let scowlful: Int? + let secluded: JSONNull? + let slackage: JSONNull? + let sphaeridial: Int? + let spondulics: JSONNull? + let subsecive: Int? + let swellmobsman: JSONNull? + let trachyglossate: Int? + let trialogue: JSONNull? + let unassuaged: Int? + let ungross: JSONNull? + let unjudiciously: JSONNull? + + enum CodingKeys: String, CodingKey { + case alicant = "Alicant" + case antiatonement = "antiatonement" + case anticorrosive = "anticorrosive" + case aphidozer = "aphidozer" + case bakuninist = "Bakuninist" + case be = "be" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case chub = "chub" + case cuprosilicon = "cuprosilicon" + case curtailedly = "curtailedly" + case dellenite = "dellenite" + case dimitry = "Dimitry" + case disdiapason = "disdiapason" + case edifying = "edifying" + case ethmoiditis = "ethmoiditis" + case gastralgy = "gastralgy" + case goatherd = "goatherd" + case hammerdress = "hammerdress" + case hangfire = "hangfire" + case homocerc = "homocerc" + case lacunosity = "lacunosity" + case longiloquence = "longiloquence" + case mameliere = "mameliere" + case motherless = "motherless" + case nonbookish = "nonbookish" + case noncorrodible = "noncorrodible" + case nonsensicality = "nonsensicality" + case oafishly = "oafishly" + case pfund = "pfund" + case preadvisory = "preadvisory" + case retroflexed = "retroflexed" + case saccharulmic = "saccharulmic" + case scowlful = "scowlful" + case secluded = "secluded" + case slackage = "slackage" + case sphaeridial = "sphaeridial" + case spondulics = "spondulics" + case subsecive = "subsecive" + case swellmobsman = "swellmobsman" + case trachyglossate = "trachyglossate" + case trialogue = "trialogue" + case unassuaged = "unassuaged" + case ungross = "ungross" + case unjudiciously = "unjudiciously" + } + + init(alicant: Int?, antiatonement: JSONNull?, anticorrosive: Int?, aphidozer: JSONNull?, bakuninist: JSONNull?, be: Int?, catharticalness: Double?, chirotherium: Int?, chub: Int?, cuprosilicon: Int?, curtailedly: Int?, dellenite: Int?, dimitry: Int?, disdiapason: String?, edifying: JSONNull?, ethmoiditis: Int?, gastralgy: JSONNull?, goatherd: Int?, hammerdress: Int?, hangfire: JSONNull?, homocerc: Bool?, lacunosity: Int?, longiloquence: JSONNull?, mameliere: Int?, motherless: JSONNull?, nonbookish: JSONNull?, noncorrodible: JSONNull?, nonsensicality: JSONNull?, oafishly: Int?, pfund: JSONNull?, preadvisory: JSONNull?, retroflexed: JSONNull?, saccharulmic: Int?, scowlful: Int?, secluded: JSONNull?, slackage: JSONNull?, sphaeridial: Int?, spondulics: JSONNull?, subsecive: Int?, swellmobsman: JSONNull?, trachyglossate: Int?, trialogue: JSONNull?, unassuaged: Int?, ungross: JSONNull?, unjudiciously: JSONNull?) { + self.alicant = alicant + self.antiatonement = antiatonement + self.anticorrosive = anticorrosive + self.aphidozer = aphidozer + self.bakuninist = bakuninist + self.be = be + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.chub = chub + self.cuprosilicon = cuprosilicon + self.curtailedly = curtailedly + self.dellenite = dellenite + self.dimitry = dimitry + self.disdiapason = disdiapason + self.edifying = edifying + self.ethmoiditis = ethmoiditis + self.gastralgy = gastralgy + self.goatherd = goatherd + self.hammerdress = hammerdress + self.hangfire = hangfire + self.homocerc = homocerc + self.lacunosity = lacunosity + self.longiloquence = longiloquence + self.mameliere = mameliere + self.motherless = motherless + self.nonbookish = nonbookish + self.noncorrodible = noncorrodible + self.nonsensicality = nonsensicality + self.oafishly = oafishly + self.pfund = pfund + self.preadvisory = preadvisory + self.retroflexed = retroflexed + self.saccharulmic = saccharulmic + self.scowlful = scowlful + self.secluded = secluded + self.slackage = slackage + self.sphaeridial = sphaeridial + self.spondulics = spondulics + self.subsecive = subsecive + self.swellmobsman = swellmobsman + self.trachyglossate = trachyglossate + self.trialogue = trialogue + self.unassuaged = unassuaged + self.ungross = ungross + self.unjudiciously = unjudiciously + } +} + +// MARK: Maslin convenience initializers and mutators + +extension Maslin { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Maslin.self, from: data) + self.init(alicant: me.alicant, antiatonement: me.antiatonement, anticorrosive: me.anticorrosive, aphidozer: me.aphidozer, bakuninist: me.bakuninist, be: me.be, catharticalness: me.catharticalness, chirotherium: me.chirotherium, chub: me.chub, cuprosilicon: me.cuprosilicon, curtailedly: me.curtailedly, dellenite: me.dellenite, dimitry: me.dimitry, disdiapason: me.disdiapason, edifying: me.edifying, ethmoiditis: me.ethmoiditis, gastralgy: me.gastralgy, goatherd: me.goatherd, hammerdress: me.hammerdress, hangfire: me.hangfire, homocerc: me.homocerc, lacunosity: me.lacunosity, longiloquence: me.longiloquence, mameliere: me.mameliere, motherless: me.motherless, nonbookish: me.nonbookish, noncorrodible: me.noncorrodible, nonsensicality: me.nonsensicality, oafishly: me.oafishly, pfund: me.pfund, preadvisory: me.preadvisory, retroflexed: me.retroflexed, saccharulmic: me.saccharulmic, scowlful: me.scowlful, secluded: me.secluded, slackage: me.slackage, sphaeridial: me.sphaeridial, spondulics: me.spondulics, subsecive: me.subsecive, swellmobsman: me.swellmobsman, trachyglossate: me.trachyglossate, trialogue: me.trialogue, unassuaged: me.unassuaged, ungross: me.ungross, unjudiciously: me.unjudiciously) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + alicant: Int?? = nil, + antiatonement: JSONNull?? = nil, + anticorrosive: Int?? = nil, + aphidozer: JSONNull?? = nil, + bakuninist: JSONNull?? = nil, + be: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + chub: Int?? = nil, + cuprosilicon: Int?? = nil, + curtailedly: Int?? = nil, + dellenite: Int?? = nil, + dimitry: Int?? = nil, + disdiapason: String?? = nil, + edifying: JSONNull?? = nil, + ethmoiditis: Int?? = nil, + gastralgy: JSONNull?? = nil, + goatherd: Int?? = nil, + hammerdress: Int?? = nil, + hangfire: JSONNull?? = nil, + homocerc: Bool?? = nil, + lacunosity: Int?? = nil, + longiloquence: JSONNull?? = nil, + mameliere: Int?? = nil, + motherless: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + noncorrodible: JSONNull?? = nil, + nonsensicality: JSONNull?? = nil, + oafishly: Int?? = nil, + pfund: JSONNull?? = nil, + preadvisory: JSONNull?? = nil, + retroflexed: JSONNull?? = nil, + saccharulmic: Int?? = nil, + scowlful: Int?? = nil, + secluded: JSONNull?? = nil, + slackage: JSONNull?? = nil, + sphaeridial: Int?? = nil, + spondulics: JSONNull?? = nil, + subsecive: Int?? = nil, + swellmobsman: JSONNull?? = nil, + trachyglossate: Int?? = nil, + trialogue: JSONNull?? = nil, + unassuaged: Int?? = nil, + ungross: JSONNull?? = nil, + unjudiciously: JSONNull?? = nil + ) -> Maslin { + return Maslin( + alicant: alicant ?? self.alicant, + antiatonement: antiatonement ?? self.antiatonement, + anticorrosive: anticorrosive ?? self.anticorrosive, + aphidozer: aphidozer ?? self.aphidozer, + bakuninist: bakuninist ?? self.bakuninist, + be: be ?? self.be, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + chub: chub ?? self.chub, + cuprosilicon: cuprosilicon ?? self.cuprosilicon, + curtailedly: curtailedly ?? self.curtailedly, + dellenite: dellenite ?? self.dellenite, + dimitry: dimitry ?? self.dimitry, + disdiapason: disdiapason ?? self.disdiapason, + edifying: edifying ?? self.edifying, + ethmoiditis: ethmoiditis ?? self.ethmoiditis, + gastralgy: gastralgy ?? self.gastralgy, + goatherd: goatherd ?? self.goatherd, + hammerdress: hammerdress ?? self.hammerdress, + hangfire: hangfire ?? self.hangfire, + homocerc: homocerc ?? self.homocerc, + lacunosity: lacunosity ?? self.lacunosity, + longiloquence: longiloquence ?? self.longiloquence, + mameliere: mameliere ?? self.mameliere, + motherless: motherless ?? self.motherless, + nonbookish: nonbookish ?? self.nonbookish, + noncorrodible: noncorrodible ?? self.noncorrodible, + nonsensicality: nonsensicality ?? self.nonsensicality, + oafishly: oafishly ?? self.oafishly, + pfund: pfund ?? self.pfund, + preadvisory: preadvisory ?? self.preadvisory, + retroflexed: retroflexed ?? self.retroflexed, + saccharulmic: saccharulmic ?? self.saccharulmic, + scowlful: scowlful ?? self.scowlful, + secluded: secluded ?? self.secluded, + slackage: slackage ?? self.slackage, + sphaeridial: sphaeridial ?? self.sphaeridial, + spondulics: spondulics ?? self.spondulics, + subsecive: subsecive ?? self.subsecive, + swellmobsman: swellmobsman ?? self.swellmobsman, + trachyglossate: trachyglossate ?? self.trachyglossate, + trialogue: trialogue ?? self.trialogue, + unassuaged: unassuaged ?? self.unassuaged, + ungross: ungross ?? self.ungross, + unjudiciously: unjudiciously ?? self.unjudiciously + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum MonaziteElement: Codable { + case double(Double) + case monaziteClass(MonaziteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(MonaziteElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for MonaziteElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + } + } +} + +// MARK: - MonaziteClass +final class MonaziteClass: Codable { + let catharticalness: Double + let chirotherium: Int + let disdiapason: String + let homocerc: Bool + let nonbookish: JSONNull? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case homocerc = "homocerc" + case nonbookish = "nonbookish" + } + + init(catharticalness: Double, chirotherium: Int, disdiapason: String, homocerc: Bool, nonbookish: JSONNull?) { + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.homocerc = homocerc + self.nonbookish = nonbookish + } +} + +// MARK: MonaziteClass convenience initializers and mutators + +extension MonaziteClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(MonaziteClass.self, from: data) + self.init(catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, homocerc: me.homocerc, nonbookish: me.nonbookish) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double? = nil, + chirotherium: Int? = nil, + disdiapason: String? = nil, + homocerc: Bool? = nil, + nonbookish: JSONNull?? = nil + ) -> MonaziteClass { + return MonaziteClass( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + homocerc: homocerc ?? self.homocerc, + nonbookish: nonbookish ?? self.nonbookish + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Monoliteral: Codable { + case bool(Bool) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + throw DecodingError.typeMismatch(Monoliteral.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Monoliteral")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum MonotheisticallyElement: Codable { + case monotheisticallyClass(MonotheisticallyClass) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(MonotheisticallyClass.self) { + self = .monotheisticallyClass(x) + return + } + throw DecodingError.typeMismatch(MonotheisticallyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for MonotheisticallyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .monotheisticallyClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +// MARK: - MonotheisticallyClass +final class MonotheisticallyClass: Codable { + let blaspheme: JSONNull? + let catharticalness: Double? + let celiosalpingectomy: JSONNull? + let chirotherium: Int? + let consummativeness: JSONNull? + let disdiapason: String? + let egestive: JSONNull? + let enchylema: JSONNull? + let gasconade: JSONNull? + let holidayer: JSONNull? + let homocerc: Bool? + let intuitionalism: JSONNull? + let lophiostomate: JSONNull? + let nonbookish: JSONNull? + let nonvolition: JSONNull? + let palatableness: JSONNull? + let pimpery: JSONNull? + let previolation: JSONNull? + let reconveyance: JSONNull? + let registership: JSONNull? + let rhyacolite: JSONNull? + let smithereens: JSONNull? + let superedification: JSONNull? + let trust: JSONNull? + let whitestone: JSONNull? + + enum CodingKeys: String, CodingKey { + case blaspheme = "blaspheme" + case catharticalness = "catharticalness" + case celiosalpingectomy = "celiosalpingectomy" + case chirotherium = "Chirotherium" + case consummativeness = "consummativeness" + case disdiapason = "disdiapason" + case egestive = "egestive" + case enchylema = "enchylema" + case gasconade = "gasconade" + case holidayer = "holidayer" + case homocerc = "homocerc" + case intuitionalism = "intuitionalism" + case lophiostomate = "lophiostomate" + case nonbookish = "nonbookish" + case nonvolition = "nonvolition" + case palatableness = "palatableness" + case pimpery = "pimpery" + case previolation = "previolation" + case reconveyance = "reconveyance" + case registership = "registership" + case rhyacolite = "rhyacolite" + case smithereens = "smithereens" + case superedification = "superedification" + case trust = "trust" + case whitestone = "whitestone" + } + + init(blaspheme: JSONNull?, catharticalness: Double?, celiosalpingectomy: JSONNull?, chirotherium: Int?, consummativeness: JSONNull?, disdiapason: String?, egestive: JSONNull?, enchylema: JSONNull?, gasconade: JSONNull?, holidayer: JSONNull?, homocerc: Bool?, intuitionalism: JSONNull?, lophiostomate: JSONNull?, nonbookish: JSONNull?, nonvolition: JSONNull?, palatableness: JSONNull?, pimpery: JSONNull?, previolation: JSONNull?, reconveyance: JSONNull?, registership: JSONNull?, rhyacolite: JSONNull?, smithereens: JSONNull?, superedification: JSONNull?, trust: JSONNull?, whitestone: JSONNull?) { + self.blaspheme = blaspheme + self.catharticalness = catharticalness + self.celiosalpingectomy = celiosalpingectomy + self.chirotherium = chirotherium + self.consummativeness = consummativeness + self.disdiapason = disdiapason + self.egestive = egestive + self.enchylema = enchylema + self.gasconade = gasconade + self.holidayer = holidayer + self.homocerc = homocerc + self.intuitionalism = intuitionalism + self.lophiostomate = lophiostomate + self.nonbookish = nonbookish + self.nonvolition = nonvolition + self.palatableness = palatableness + self.pimpery = pimpery + self.previolation = previolation + self.reconveyance = reconveyance + self.registership = registership + self.rhyacolite = rhyacolite + self.smithereens = smithereens + self.superedification = superedification + self.trust = trust + self.whitestone = whitestone + } +} + +// MARK: MonotheisticallyClass convenience initializers and mutators + +extension MonotheisticallyClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(MonotheisticallyClass.self, from: data) + self.init(blaspheme: me.blaspheme, catharticalness: me.catharticalness, celiosalpingectomy: me.celiosalpingectomy, chirotherium: me.chirotherium, consummativeness: me.consummativeness, disdiapason: me.disdiapason, egestive: me.egestive, enchylema: me.enchylema, gasconade: me.gasconade, holidayer: me.holidayer, homocerc: me.homocerc, intuitionalism: me.intuitionalism, lophiostomate: me.lophiostomate, nonbookish: me.nonbookish, nonvolition: me.nonvolition, palatableness: me.palatableness, pimpery: me.pimpery, previolation: me.previolation, reconveyance: me.reconveyance, registership: me.registership, rhyacolite: me.rhyacolite, smithereens: me.smithereens, superedification: me.superedification, trust: me.trust, whitestone: me.whitestone) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + blaspheme: JSONNull?? = nil, + catharticalness: Double?? = nil, + celiosalpingectomy: JSONNull?? = nil, + chirotherium: Int?? = nil, + consummativeness: JSONNull?? = nil, + disdiapason: String?? = nil, + egestive: JSONNull?? = nil, + enchylema: JSONNull?? = nil, + gasconade: JSONNull?? = nil, + holidayer: JSONNull?? = nil, + homocerc: Bool?? = nil, + intuitionalism: JSONNull?? = nil, + lophiostomate: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + nonvolition: JSONNull?? = nil, + palatableness: JSONNull?? = nil, + pimpery: JSONNull?? = nil, + previolation: JSONNull?? = nil, + reconveyance: JSONNull?? = nil, + registership: JSONNull?? = nil, + rhyacolite: JSONNull?? = nil, + smithereens: JSONNull?? = nil, + superedification: JSONNull?? = nil, + trust: JSONNull?? = nil, + whitestone: JSONNull?? = nil + ) -> MonotheisticallyClass { + return MonotheisticallyClass( + blaspheme: blaspheme ?? self.blaspheme, + catharticalness: catharticalness ?? self.catharticalness, + celiosalpingectomy: celiosalpingectomy ?? self.celiosalpingectomy, + chirotherium: chirotherium ?? self.chirotherium, + consummativeness: consummativeness ?? self.consummativeness, + disdiapason: disdiapason ?? self.disdiapason, + egestive: egestive ?? self.egestive, + enchylema: enchylema ?? self.enchylema, + gasconade: gasconade ?? self.gasconade, + holidayer: holidayer ?? self.holidayer, + homocerc: homocerc ?? self.homocerc, + intuitionalism: intuitionalism ?? self.intuitionalism, + lophiostomate: lophiostomate ?? self.lophiostomate, + nonbookish: nonbookish ?? self.nonbookish, + nonvolition: nonvolition ?? self.nonvolition, + palatableness: palatableness ?? self.palatableness, + pimpery: pimpery ?? self.pimpery, + previolation: previolation ?? self.previolation, + reconveyance: reconveyance ?? self.reconveyance, + registership: registership ?? self.registership, + rhyacolite: rhyacolite ?? self.rhyacolite, + smithereens: smithereens ?? self.smithereens, + superedification: superedification ?? self.superedification, + trust: trust ?? self.trust, + whitestone: whitestone ?? self.whitestone + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Montage: Codable { + case double(Double) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Montage.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Montage")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Moralness: Codable { + case double(Double) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Moralness.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Moralness")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Mulishly: Codable { + case double(Double) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Mulishly.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Mulishly")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Myoscope: Codable { + case bool(Bool) + case integer(Int) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + throw DecodingError.typeMismatch(Myoscope.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Myoscope")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Neuromastic: Codable { + case double(Double) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Neuromastic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Neuromastic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +// MARK: - Noncontributing +final class Noncontributing: Codable { + let estevin: String + let jolterhead: Double + let sauternes: Int + let sparsely: Bool + let unrequested: JSONNull? + + enum CodingKeys: String, CodingKey { + case estevin = "estevin" + case jolterhead = "jolterhead" + case sauternes = "sauternes" + case sparsely = "sparsely" + case unrequested = "unrequested" + } + + init(estevin: String, jolterhead: Double, sauternes: Int, sparsely: Bool, unrequested: JSONNull?) { + self.estevin = estevin + self.jolterhead = jolterhead + self.sauternes = sauternes + self.sparsely = sparsely + self.unrequested = unrequested + } +} + +// MARK: Noncontributing convenience initializers and mutators + +extension Noncontributing { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Noncontributing.self, from: data) + self.init(estevin: me.estevin, jolterhead: me.jolterhead, sauternes: me.sauternes, sparsely: me.sparsely, unrequested: me.unrequested) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + estevin: String? = nil, + jolterhead: Double? = nil, + sauternes: Int? = nil, + sparsely: Bool? = nil, + unrequested: JSONNull?? = nil + ) -> Noncontributing { + return Noncontributing( + estevin: estevin ?? self.estevin, + jolterhead: jolterhead ?? self.jolterhead, + sauternes: sauternes ?? self.sauternes, + sparsely: sparsely ?? self.sparsely, + unrequested: unrequested ?? self.unrequested + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Nonnervous: Codable { + case bool(Bool) + case integer(Int) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + throw DecodingError.typeMismatch(Nonnervous.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Nonnervous")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + } + } +} + +enum Nonvaluation: Codable { + case bool(Bool) + case double(Double) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Nonvaluation.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Nonvaluation")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum OccupationalistElement: Codable { + case nullArray([JSONNull?]) + case occupationalistClass(OccupationalistClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(OccupationalistClass.self) { + self = .occupationalistClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(OccupationalistElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for OccupationalistElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .occupationalistClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - OccupationalistClass +final class OccupationalistClass: Codable { + let beholdable: JSONNull? + let brotuliform: JSONNull? + let chimakum: JSONNull? + let doodler: JSONNull? + let emulsin: JSONNull? + let fin: JSONNull? + let flourishing: JSONNull? + let flueless: JSONNull? + let furtively: JSONNull? + let gritter: JSONNull? + let interwish: JSONNull? + let monoxylic: JSONNull? + let myristic: JSONNull? + let nightwear: JSONNull? + let peruser: JSONNull? + let theoastrological: JSONNull? + let thumby: JSONNull? + let tingitid: JSONNull? + let trailless: JSONNull? + let unpocketed: JSONNull? + + enum CodingKeys: String, CodingKey { + case beholdable = "beholdable" + case brotuliform = "brotuliform" + case chimakum = "Chimakum" + case doodler = "doodler" + case emulsin = "emulsin" + case fin = "Fin" + case flourishing = "flourishing" + case flueless = "flueless" + case furtively = "furtively" + case gritter = "gritter" + case interwish = "interwish" + case monoxylic = "monoxylic" + case myristic = "myristic" + case nightwear = "nightwear" + case peruser = "peruser" + case theoastrological = "theoastrological" + case thumby = "thumby" + case tingitid = "tingitid" + case trailless = "trailless" + case unpocketed = "unpocketed" + } + + init(beholdable: JSONNull?, brotuliform: JSONNull?, chimakum: JSONNull?, doodler: JSONNull?, emulsin: JSONNull?, fin: JSONNull?, flourishing: JSONNull?, flueless: JSONNull?, furtively: JSONNull?, gritter: JSONNull?, interwish: JSONNull?, monoxylic: JSONNull?, myristic: JSONNull?, nightwear: JSONNull?, peruser: JSONNull?, theoastrological: JSONNull?, thumby: JSONNull?, tingitid: JSONNull?, trailless: JSONNull?, unpocketed: JSONNull?) { + self.beholdable = beholdable + self.brotuliform = brotuliform + self.chimakum = chimakum + self.doodler = doodler + self.emulsin = emulsin + self.fin = fin + self.flourishing = flourishing + self.flueless = flueless + self.furtively = furtively + self.gritter = gritter + self.interwish = interwish + self.monoxylic = monoxylic + self.myristic = myristic + self.nightwear = nightwear + self.peruser = peruser + self.theoastrological = theoastrological + self.thumby = thumby + self.tingitid = tingitid + self.trailless = trailless + self.unpocketed = unpocketed + } +} + +// MARK: OccupationalistClass convenience initializers and mutators + +extension OccupationalistClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(OccupationalistClass.self, from: data) + self.init(beholdable: me.beholdable, brotuliform: me.brotuliform, chimakum: me.chimakum, doodler: me.doodler, emulsin: me.emulsin, fin: me.fin, flourishing: me.flourishing, flueless: me.flueless, furtively: me.furtively, gritter: me.gritter, interwish: me.interwish, monoxylic: me.monoxylic, myristic: me.myristic, nightwear: me.nightwear, peruser: me.peruser, theoastrological: me.theoastrological, thumby: me.thumby, tingitid: me.tingitid, trailless: me.trailless, unpocketed: me.unpocketed) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + beholdable: JSONNull?? = nil, + brotuliform: JSONNull?? = nil, + chimakum: JSONNull?? = nil, + doodler: JSONNull?? = nil, + emulsin: JSONNull?? = nil, + fin: JSONNull?? = nil, + flourishing: JSONNull?? = nil, + flueless: JSONNull?? = nil, + furtively: JSONNull?? = nil, + gritter: JSONNull?? = nil, + interwish: JSONNull?? = nil, + monoxylic: JSONNull?? = nil, + myristic: JSONNull?? = nil, + nightwear: JSONNull?? = nil, + peruser: JSONNull?? = nil, + theoastrological: JSONNull?? = nil, + thumby: JSONNull?? = nil, + tingitid: JSONNull?? = nil, + trailless: JSONNull?? = nil, + unpocketed: JSONNull?? = nil + ) -> OccupationalistClass { + return OccupationalistClass( + beholdable: beholdable ?? self.beholdable, + brotuliform: brotuliform ?? self.brotuliform, + chimakum: chimakum ?? self.chimakum, + doodler: doodler ?? self.doodler, + emulsin: emulsin ?? self.emulsin, + fin: fin ?? self.fin, + flourishing: flourishing ?? self.flourishing, + flueless: flueless ?? self.flueless, + furtively: furtively ?? self.furtively, + gritter: gritter ?? self.gritter, + interwish: interwish ?? self.interwish, + monoxylic: monoxylic ?? self.monoxylic, + myristic: myristic ?? self.myristic, + nightwear: nightwear ?? self.nightwear, + peruser: peruser ?? self.peruser, + theoastrological: theoastrological ?? self.theoastrological, + thumby: thumby ?? self.thumby, + tingitid: tingitid ?? self.tingitid, + trailless: trailless ?? self.trailless, + unpocketed: unpocketed ?? self.unpocketed + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum OutrivalElement: Codable { + case double(Double) + case outrivalClass(OutrivalClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(OutrivalClass.self) { + self = .outrivalClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(OutrivalElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for OutrivalElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .outrivalClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - OutrivalClass +final class OutrivalClass: Codable { + let adroitly: JSONNull? + let bridehood: JSONNull? + let castoroides: JSONNull? + let czechoslovak: JSONNull? + let diagenesis: JSONNull? + let dihexahedron: JSONNull? + let dopester: JSONNull? + let eumerism: JSONNull? + let flyness: JSONNull? + let fouler: JSONNull? + let laudanosine: JSONNull? + let lingulidae: JSONNull? + let minutary: JSONNull? + let mitra: JSONNull? + let opisthorchiasis: JSONNull? + let pensively: JSONNull? + let pubigerous: JSONNull? + let rebellious: JSONNull? + let recodify: JSONNull? + let unpaced: JSONNull? + + enum CodingKeys: String, CodingKey { + case adroitly = "adroitly" + case bridehood = "bridehood" + case castoroides = "Castoroides" + case czechoslovak = "Czechoslovak" + case diagenesis = "diagenesis" + case dihexahedron = "dihexahedron" + case dopester = "dopester" + case eumerism = "eumerism" + case flyness = "flyness" + case fouler = "fouler" + case laudanosine = "laudanosine" + case lingulidae = "Lingulidae" + case minutary = "minutary" + case mitra = "mitra" + case opisthorchiasis = "opisthorchiasis" + case pensively = "pensively" + case pubigerous = "pubigerous" + case rebellious = "rebellious" + case recodify = "recodify" + case unpaced = "unpaced" + } + + init(adroitly: JSONNull?, bridehood: JSONNull?, castoroides: JSONNull?, czechoslovak: JSONNull?, diagenesis: JSONNull?, dihexahedron: JSONNull?, dopester: JSONNull?, eumerism: JSONNull?, flyness: JSONNull?, fouler: JSONNull?, laudanosine: JSONNull?, lingulidae: JSONNull?, minutary: JSONNull?, mitra: JSONNull?, opisthorchiasis: JSONNull?, pensively: JSONNull?, pubigerous: JSONNull?, rebellious: JSONNull?, recodify: JSONNull?, unpaced: JSONNull?) { + self.adroitly = adroitly + self.bridehood = bridehood + self.castoroides = castoroides + self.czechoslovak = czechoslovak + self.diagenesis = diagenesis + self.dihexahedron = dihexahedron + self.dopester = dopester + self.eumerism = eumerism + self.flyness = flyness + self.fouler = fouler + self.laudanosine = laudanosine + self.lingulidae = lingulidae + self.minutary = minutary + self.mitra = mitra + self.opisthorchiasis = opisthorchiasis + self.pensively = pensively + self.pubigerous = pubigerous + self.rebellious = rebellious + self.recodify = recodify + self.unpaced = unpaced + } +} + +// MARK: OutrivalClass convenience initializers and mutators + +extension OutrivalClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(OutrivalClass.self, from: data) + self.init(adroitly: me.adroitly, bridehood: me.bridehood, castoroides: me.castoroides, czechoslovak: me.czechoslovak, diagenesis: me.diagenesis, dihexahedron: me.dihexahedron, dopester: me.dopester, eumerism: me.eumerism, flyness: me.flyness, fouler: me.fouler, laudanosine: me.laudanosine, lingulidae: me.lingulidae, minutary: me.minutary, mitra: me.mitra, opisthorchiasis: me.opisthorchiasis, pensively: me.pensively, pubigerous: me.pubigerous, rebellious: me.rebellious, recodify: me.recodify, unpaced: me.unpaced) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + adroitly: JSONNull?? = nil, + bridehood: JSONNull?? = nil, + castoroides: JSONNull?? = nil, + czechoslovak: JSONNull?? = nil, + diagenesis: JSONNull?? = nil, + dihexahedron: JSONNull?? = nil, + dopester: JSONNull?? = nil, + eumerism: JSONNull?? = nil, + flyness: JSONNull?? = nil, + fouler: JSONNull?? = nil, + laudanosine: JSONNull?? = nil, + lingulidae: JSONNull?? = nil, + minutary: JSONNull?? = nil, + mitra: JSONNull?? = nil, + opisthorchiasis: JSONNull?? = nil, + pensively: JSONNull?? = nil, + pubigerous: JSONNull?? = nil, + rebellious: JSONNull?? = nil, + recodify: JSONNull?? = nil, + unpaced: JSONNull?? = nil + ) -> OutrivalClass { + return OutrivalClass( + adroitly: adroitly ?? self.adroitly, + bridehood: bridehood ?? self.bridehood, + castoroides: castoroides ?? self.castoroides, + czechoslovak: czechoslovak ?? self.czechoslovak, + diagenesis: diagenesis ?? self.diagenesis, + dihexahedron: dihexahedron ?? self.dihexahedron, + dopester: dopester ?? self.dopester, + eumerism: eumerism ?? self.eumerism, + flyness: flyness ?? self.flyness, + fouler: fouler ?? self.fouler, + laudanosine: laudanosine ?? self.laudanosine, + lingulidae: lingulidae ?? self.lingulidae, + minutary: minutary ?? self.minutary, + mitra: mitra ?? self.mitra, + opisthorchiasis: opisthorchiasis ?? self.opisthorchiasis, + pensively: pensively ?? self.pensively, + pubigerous: pubigerous ?? self.pubigerous, + rebellious: rebellious ?? self.rebellious, + recodify: recodify ?? self.recodify, + unpaced: unpaced ?? self.unpaced + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Paleographically: Codable { + case double(Double) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Paleographically.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Paleographically")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +enum Pamphletwise: Codable { + case integer(Int) + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Pamphletwise.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Pamphletwise")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Pediatric: Codable { + case bool(Bool) + case double(Double) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Pediatric.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Pediatric")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum PiaculumElement: Codable { + case double(Double) + case piaculumClass(PiaculumClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(PiaculumClass.self) { + self = .piaculumClass(x) + return + } + throw DecodingError.typeMismatch(PiaculumElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PiaculumElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .piaculumClass(let x): + try container.encode(x) + } + } +} + +// MARK: - PiaculumClass +final class PiaculumClass: Codable { + let alada: Int? + let amphistomous: Int? + let boysenberry: Int? + let catharticalness: Double? + let chirotherium: Int? + let decardinalize: Int? + let discouragement: Int? + let disdiapason: String? + let doitrified: Int? + let hexaspermous: Int? + let homocerc: Bool? + let insinking: Int? + let loathfulness: Int? + let miasmatical: Int? + let neurofibril: Int? + let nonbookish: JSONNull? + let phonendoscope: Int? + let pilferment: Int? + let predismissory: Int? + let preinscription: Int? + let quotative: Int? + let sienna: Int? + let thorax: Int? + let yachting: Int? + let zipper: Int? + + enum CodingKeys: String, CodingKey { + case alada = "alada" + case amphistomous = "amphistomous" + case boysenberry = "boysenberry" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case decardinalize = "decardinalize" + case discouragement = "discouragement" + case disdiapason = "disdiapason" + case doitrified = "doitrified" + case hexaspermous = "hexaspermous" + case homocerc = "homocerc" + case insinking = "insinking" + case loathfulness = "loathfulness" + case miasmatical = "miasmatical" + case neurofibril = "neurofibril" + case nonbookish = "nonbookish" + case phonendoscope = "phonendoscope" + case pilferment = "pilferment" + case predismissory = "predismissory" + case preinscription = "preinscription" + case quotative = "quotative" + case sienna = "sienna" + case thorax = "thorax" + case yachting = "yachting" + case zipper = "Zipper" + } + + init(alada: Int?, amphistomous: Int?, boysenberry: Int?, catharticalness: Double?, chirotherium: Int?, decardinalize: Int?, discouragement: Int?, disdiapason: String?, doitrified: Int?, hexaspermous: Int?, homocerc: Bool?, insinking: Int?, loathfulness: Int?, miasmatical: Int?, neurofibril: Int?, nonbookish: JSONNull?, phonendoscope: Int?, pilferment: Int?, predismissory: Int?, preinscription: Int?, quotative: Int?, sienna: Int?, thorax: Int?, yachting: Int?, zipper: Int?) { + self.alada = alada + self.amphistomous = amphistomous + self.boysenberry = boysenberry + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.decardinalize = decardinalize + self.discouragement = discouragement + self.disdiapason = disdiapason + self.doitrified = doitrified + self.hexaspermous = hexaspermous + self.homocerc = homocerc + self.insinking = insinking + self.loathfulness = loathfulness + self.miasmatical = miasmatical + self.neurofibril = neurofibril + self.nonbookish = nonbookish + self.phonendoscope = phonendoscope + self.pilferment = pilferment + self.predismissory = predismissory + self.preinscription = preinscription + self.quotative = quotative + self.sienna = sienna + self.thorax = thorax + self.yachting = yachting + self.zipper = zipper + } +} + +// MARK: PiaculumClass convenience initializers and mutators + +extension PiaculumClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(PiaculumClass.self, from: data) + self.init(alada: me.alada, amphistomous: me.amphistomous, boysenberry: me.boysenberry, catharticalness: me.catharticalness, chirotherium: me.chirotherium, decardinalize: me.decardinalize, discouragement: me.discouragement, disdiapason: me.disdiapason, doitrified: me.doitrified, hexaspermous: me.hexaspermous, homocerc: me.homocerc, insinking: me.insinking, loathfulness: me.loathfulness, miasmatical: me.miasmatical, neurofibril: me.neurofibril, nonbookish: me.nonbookish, phonendoscope: me.phonendoscope, pilferment: me.pilferment, predismissory: me.predismissory, preinscription: me.preinscription, quotative: me.quotative, sienna: me.sienna, thorax: me.thorax, yachting: me.yachting, zipper: me.zipper) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + alada: Int?? = nil, + amphistomous: Int?? = nil, + boysenberry: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + decardinalize: Int?? = nil, + discouragement: Int?? = nil, + disdiapason: String?? = nil, + doitrified: Int?? = nil, + hexaspermous: Int?? = nil, + homocerc: Bool?? = nil, + insinking: Int?? = nil, + loathfulness: Int?? = nil, + miasmatical: Int?? = nil, + neurofibril: Int?? = nil, + nonbookish: JSONNull?? = nil, + phonendoscope: Int?? = nil, + pilferment: Int?? = nil, + predismissory: Int?? = nil, + preinscription: Int?? = nil, + quotative: Int?? = nil, + sienna: Int?? = nil, + thorax: Int?? = nil, + yachting: Int?? = nil, + zipper: Int?? = nil + ) -> PiaculumClass { + return PiaculumClass( + alada: alada ?? self.alada, + amphistomous: amphistomous ?? self.amphistomous, + boysenberry: boysenberry ?? self.boysenberry, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + decardinalize: decardinalize ?? self.decardinalize, + discouragement: discouragement ?? self.discouragement, + disdiapason: disdiapason ?? self.disdiapason, + doitrified: doitrified ?? self.doitrified, + hexaspermous: hexaspermous ?? self.hexaspermous, + homocerc: homocerc ?? self.homocerc, + insinking: insinking ?? self.insinking, + loathfulness: loathfulness ?? self.loathfulness, + miasmatical: miasmatical ?? self.miasmatical, + neurofibril: neurofibril ?? self.neurofibril, + nonbookish: nonbookish ?? self.nonbookish, + phonendoscope: phonendoscope ?? self.phonendoscope, + pilferment: pilferment ?? self.pilferment, + predismissory: predismissory ?? self.predismissory, + preinscription: preinscription ?? self.preinscription, + quotative: quotative ?? self.quotative, + sienna: sienna ?? self.sienna, + thorax: thorax ?? self.thorax, + yachting: yachting ?? self.yachting, + zipper: zipper ?? self.zipper + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Piccadilly: Codable { + case double(Double) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Piccadilly.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Piccadilly")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Piffler: Codable { + case monaziteClass(MonaziteClass) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Piffler.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Piffler")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .monaziteClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Pithful: Codable { + case bool(Bool) + case integer(Int) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Pithful.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Pithful")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Placuntiti: Codable { + case integer(Int) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Placuntiti.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Placuntiti")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Plectopterous: Codable { + case double(Double) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Plectopterous.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Plectopterous")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +// MARK: - Pneumocele +final class Pneumocele: Codable { + let carbonarism: JSONNull? + let catharticalness: Double? + let chirotherium: Int? + let cineolic: JSONNull? + let cobbly: JSONNull? + let conchyliferous: JSONNull? + let congregation: JSONNull? + let disdiapason: String? + let enterotomy: JSONNull? + let entophytal: JSONNull? + let fewtrils: JSONNull? + let herem: JSONNull? + let homocerc: Bool? + let koniga: JSONNull? + let meticulosity: JSONNull? + let micky: JSONNull? + let mismarriage: JSONNull? + let neurotrophic: JSONNull? + let nonbookish: JSONNull? + let persuasively: JSONNull? + let replaceable: JSONNull? + let silex: JSONNull? + let taillight: JSONNull? + let unjealous: JSONNull? + let visitorial: JSONNull? + + enum CodingKeys: String, CodingKey { + case carbonarism = "Carbonarism" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case cineolic = "cineolic" + case cobbly = "cobbly" + case conchyliferous = "conchyliferous" + case congregation = "congregation" + case disdiapason = "disdiapason" + case enterotomy = "enterotomy" + case entophytal = "entophytal" + case fewtrils = "fewtrils" + case herem = "herem" + case homocerc = "homocerc" + case koniga = "Koniga" + case meticulosity = "meticulosity" + case micky = "Micky" + case mismarriage = "mismarriage" + case neurotrophic = "neurotrophic" + case nonbookish = "nonbookish" + case persuasively = "persuasively" + case replaceable = "replaceable" + case silex = "silex" + case taillight = "taillight" + case unjealous = "unjealous" + case visitorial = "visitorial" + } + + init(carbonarism: JSONNull?, catharticalness: Double?, chirotherium: Int?, cineolic: JSONNull?, cobbly: JSONNull?, conchyliferous: JSONNull?, congregation: JSONNull?, disdiapason: String?, enterotomy: JSONNull?, entophytal: JSONNull?, fewtrils: JSONNull?, herem: JSONNull?, homocerc: Bool?, koniga: JSONNull?, meticulosity: JSONNull?, micky: JSONNull?, mismarriage: JSONNull?, neurotrophic: JSONNull?, nonbookish: JSONNull?, persuasively: JSONNull?, replaceable: JSONNull?, silex: JSONNull?, taillight: JSONNull?, unjealous: JSONNull?, visitorial: JSONNull?) { + self.carbonarism = carbonarism + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.cineolic = cineolic + self.cobbly = cobbly + self.conchyliferous = conchyliferous + self.congregation = congregation + self.disdiapason = disdiapason + self.enterotomy = enterotomy + self.entophytal = entophytal + self.fewtrils = fewtrils + self.herem = herem + self.homocerc = homocerc + self.koniga = koniga + self.meticulosity = meticulosity + self.micky = micky + self.mismarriage = mismarriage + self.neurotrophic = neurotrophic + self.nonbookish = nonbookish + self.persuasively = persuasively + self.replaceable = replaceable + self.silex = silex + self.taillight = taillight + self.unjealous = unjealous + self.visitorial = visitorial + } +} + +// MARK: Pneumocele convenience initializers and mutators + +extension Pneumocele { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Pneumocele.self, from: data) + self.init(carbonarism: me.carbonarism, catharticalness: me.catharticalness, chirotherium: me.chirotherium, cineolic: me.cineolic, cobbly: me.cobbly, conchyliferous: me.conchyliferous, congregation: me.congregation, disdiapason: me.disdiapason, enterotomy: me.enterotomy, entophytal: me.entophytal, fewtrils: me.fewtrils, herem: me.herem, homocerc: me.homocerc, koniga: me.koniga, meticulosity: me.meticulosity, micky: me.micky, mismarriage: me.mismarriage, neurotrophic: me.neurotrophic, nonbookish: me.nonbookish, persuasively: me.persuasively, replaceable: me.replaceable, silex: me.silex, taillight: me.taillight, unjealous: me.unjealous, visitorial: me.visitorial) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + carbonarism: JSONNull?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + cineolic: JSONNull?? = nil, + cobbly: JSONNull?? = nil, + conchyliferous: JSONNull?? = nil, + congregation: JSONNull?? = nil, + disdiapason: String?? = nil, + enterotomy: JSONNull?? = nil, + entophytal: JSONNull?? = nil, + fewtrils: JSONNull?? = nil, + herem: JSONNull?? = nil, + homocerc: Bool?? = nil, + koniga: JSONNull?? = nil, + meticulosity: JSONNull?? = nil, + micky: JSONNull?? = nil, + mismarriage: JSONNull?? = nil, + neurotrophic: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + persuasively: JSONNull?? = nil, + replaceable: JSONNull?? = nil, + silex: JSONNull?? = nil, + taillight: JSONNull?? = nil, + unjealous: JSONNull?? = nil, + visitorial: JSONNull?? = nil + ) -> Pneumocele { + return Pneumocele( + carbonarism: carbonarism ?? self.carbonarism, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + cineolic: cineolic ?? self.cineolic, + cobbly: cobbly ?? self.cobbly, + conchyliferous: conchyliferous ?? self.conchyliferous, + congregation: congregation ?? self.congregation, + disdiapason: disdiapason ?? self.disdiapason, + enterotomy: enterotomy ?? self.enterotomy, + entophytal: entophytal ?? self.entophytal, + fewtrils: fewtrils ?? self.fewtrils, + herem: herem ?? self.herem, + homocerc: homocerc ?? self.homocerc, + koniga: koniga ?? self.koniga, + meticulosity: meticulosity ?? self.meticulosity, + micky: micky ?? self.micky, + mismarriage: mismarriage ?? self.mismarriage, + neurotrophic: neurotrophic ?? self.neurotrophic, + nonbookish: nonbookish ?? self.nonbookish, + persuasively: persuasively ?? self.persuasively, + replaceable: replaceable ?? self.replaceable, + silex: silex ?? self.silex, + taillight: taillight ?? self.taillight, + unjealous: unjealous ?? self.unjealous, + visitorial: visitorial ?? self.visitorial + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Poliorcetic: Codable { + case bool(Bool) + case monaziteClass(MonaziteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Poliorcetic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Poliorcetic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + } + } +} + +enum Poormaster: Codable { + case integerArray([Int]) + case integerMap([String: Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Poormaster.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Poormaster")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum PotwhiskyElement: Codable { + case integer(Int) + case potwhiskyClass(PotwhiskyClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(PotwhiskyClass.self) { + self = .potwhiskyClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(PotwhiskyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PotwhiskyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .potwhiskyClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - PotwhiskyClass +final class PotwhiskyClass: Codable { + let arciform: JSONNull? + let cresolin: JSONNull? + let disheartener: JSONNull? + let disproportionable: JSONNull? + let euchorda: JSONNull? + let ferryway: JSONNull? + let filamentiferous: JSONNull? + let flemish: JSONNull? + let forgainst: JSONNull? + let grainering: JSONNull? + let irrevoluble: JSONNull? + let kindredship: JSONNull? + let pinguitudinous: JSONNull? + let simpletonic: JSONNull? + let singsong: JSONNull? + let submergement: JSONNull? + let supraoesophagal: JSONNull? + let thrashel: JSONNull? + let tyremesis: JSONNull? + let yoruba: JSONNull? + + enum CodingKeys: String, CodingKey { + case arciform = "arciform" + case cresolin = "cresolin" + case disheartener = "disheartener" + case disproportionable = "disproportionable" + case euchorda = "Euchorda" + case ferryway = "ferryway" + case filamentiferous = "filamentiferous" + case flemish = "flemish" + case forgainst = "forgainst" + case grainering = "grainering" + case irrevoluble = "irrevoluble" + case kindredship = "kindredship" + case pinguitudinous = "pinguitudinous" + case simpletonic = "simpletonic" + case singsong = "singsong" + case submergement = "submergement" + case supraoesophagal = "supraoesophagal" + case thrashel = "thrashel" + case tyremesis = "tyremesis" + case yoruba = "Yoruba" + } + + init(arciform: JSONNull?, cresolin: JSONNull?, disheartener: JSONNull?, disproportionable: JSONNull?, euchorda: JSONNull?, ferryway: JSONNull?, filamentiferous: JSONNull?, flemish: JSONNull?, forgainst: JSONNull?, grainering: JSONNull?, irrevoluble: JSONNull?, kindredship: JSONNull?, pinguitudinous: JSONNull?, simpletonic: JSONNull?, singsong: JSONNull?, submergement: JSONNull?, supraoesophagal: JSONNull?, thrashel: JSONNull?, tyremesis: JSONNull?, yoruba: JSONNull?) { + self.arciform = arciform + self.cresolin = cresolin + self.disheartener = disheartener + self.disproportionable = disproportionable + self.euchorda = euchorda + self.ferryway = ferryway + self.filamentiferous = filamentiferous + self.flemish = flemish + self.forgainst = forgainst + self.grainering = grainering + self.irrevoluble = irrevoluble + self.kindredship = kindredship + self.pinguitudinous = pinguitudinous + self.simpletonic = simpletonic + self.singsong = singsong + self.submergement = submergement + self.supraoesophagal = supraoesophagal + self.thrashel = thrashel + self.tyremesis = tyremesis + self.yoruba = yoruba + } +} + +// MARK: PotwhiskyClass convenience initializers and mutators + +extension PotwhiskyClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(PotwhiskyClass.self, from: data) + self.init(arciform: me.arciform, cresolin: me.cresolin, disheartener: me.disheartener, disproportionable: me.disproportionable, euchorda: me.euchorda, ferryway: me.ferryway, filamentiferous: me.filamentiferous, flemish: me.flemish, forgainst: me.forgainst, grainering: me.grainering, irrevoluble: me.irrevoluble, kindredship: me.kindredship, pinguitudinous: me.pinguitudinous, simpletonic: me.simpletonic, singsong: me.singsong, submergement: me.submergement, supraoesophagal: me.supraoesophagal, thrashel: me.thrashel, tyremesis: me.tyremesis, yoruba: me.yoruba) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + arciform: JSONNull?? = nil, + cresolin: JSONNull?? = nil, + disheartener: JSONNull?? = nil, + disproportionable: JSONNull?? = nil, + euchorda: JSONNull?? = nil, + ferryway: JSONNull?? = nil, + filamentiferous: JSONNull?? = nil, + flemish: JSONNull?? = nil, + forgainst: JSONNull?? = nil, + grainering: JSONNull?? = nil, + irrevoluble: JSONNull?? = nil, + kindredship: JSONNull?? = nil, + pinguitudinous: JSONNull?? = nil, + simpletonic: JSONNull?? = nil, + singsong: JSONNull?? = nil, + submergement: JSONNull?? = nil, + supraoesophagal: JSONNull?? = nil, + thrashel: JSONNull?? = nil, + tyremesis: JSONNull?? = nil, + yoruba: JSONNull?? = nil + ) -> PotwhiskyClass { + return PotwhiskyClass( + arciform: arciform ?? self.arciform, + cresolin: cresolin ?? self.cresolin, + disheartener: disheartener ?? self.disheartener, + disproportionable: disproportionable ?? self.disproportionable, + euchorda: euchorda ?? self.euchorda, + ferryway: ferryway ?? self.ferryway, + filamentiferous: filamentiferous ?? self.filamentiferous, + flemish: flemish ?? self.flemish, + forgainst: forgainst ?? self.forgainst, + grainering: grainering ?? self.grainering, + irrevoluble: irrevoluble ?? self.irrevoluble, + kindredship: kindredship ?? self.kindredship, + pinguitudinous: pinguitudinous ?? self.pinguitudinous, + simpletonic: simpletonic ?? self.simpletonic, + singsong: singsong ?? self.singsong, + submergement: submergement ?? self.submergement, + supraoesophagal: supraoesophagal ?? self.supraoesophagal, + thrashel: thrashel ?? self.thrashel, + tyremesis: tyremesis ?? self.tyremesis, + yoruba: yoruba ?? self.yoruba + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Practicalizer: Codable { + case monaziteClass(MonaziteClass) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Practicalizer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Practicalizer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .monaziteClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum PrefreshmanElement: Codable { + case nullArray([JSONNull?]) + case prefreshmanClass(PrefreshmanClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(PrefreshmanClass.self) { + self = .prefreshmanClass(x) + return + } + throw DecodingError.typeMismatch(PrefreshmanElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PrefreshmanElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .prefreshmanClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - PrefreshmanClass +final class PrefreshmanClass: Codable { + let azorubine: JSONNull? + let choroiditis: JSONNull? + let coagulatory: JSONNull? + let cyclorama: JSONNull? + let dolphus: JSONNull? + let duckhearted: JSONNull? + let ficus: JSONNull? + let gemaric: JSONNull? + let jugation: JSONNull? + let myoliposis: JSONNull? + let nonnomination: JSONNull? + let palay: JSONNull? + let pentactinal: JSONNull? + let phaet: JSONNull? + let piquant: JSONNull? + let registration: JSONNull? + let remancipation: JSONNull? + let scutatiform: JSONNull? + let theodolite: JSONNull? + let underward: JSONNull? + + enum CodingKeys: String, CodingKey { + case azorubine = "azorubine" + case choroiditis = "choroiditis" + case coagulatory = "coagulatory" + case cyclorama = "cyclorama" + case dolphus = "Dolphus" + case duckhearted = "duckhearted" + case ficus = "Ficus" + case gemaric = "Gemaric" + case jugation = "jugation" + case myoliposis = "myoliposis" + case nonnomination = "nonnomination" + case palay = "palay" + case pentactinal = "pentactinal" + case phaet = "Phaet" + case piquant = "piquant" + case registration = "registration" + case remancipation = "remancipation" + case scutatiform = "scutatiform" + case theodolite = "theodolite" + case underward = "underward" + } + + init(azorubine: JSONNull?, choroiditis: JSONNull?, coagulatory: JSONNull?, cyclorama: JSONNull?, dolphus: JSONNull?, duckhearted: JSONNull?, ficus: JSONNull?, gemaric: JSONNull?, jugation: JSONNull?, myoliposis: JSONNull?, nonnomination: JSONNull?, palay: JSONNull?, pentactinal: JSONNull?, phaet: JSONNull?, piquant: JSONNull?, registration: JSONNull?, remancipation: JSONNull?, scutatiform: JSONNull?, theodolite: JSONNull?, underward: JSONNull?) { + self.azorubine = azorubine + self.choroiditis = choroiditis + self.coagulatory = coagulatory + self.cyclorama = cyclorama + self.dolphus = dolphus + self.duckhearted = duckhearted + self.ficus = ficus + self.gemaric = gemaric + self.jugation = jugation + self.myoliposis = myoliposis + self.nonnomination = nonnomination + self.palay = palay + self.pentactinal = pentactinal + self.phaet = phaet + self.piquant = piquant + self.registration = registration + self.remancipation = remancipation + self.scutatiform = scutatiform + self.theodolite = theodolite + self.underward = underward + } +} + +// MARK: PrefreshmanClass convenience initializers and mutators + +extension PrefreshmanClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(PrefreshmanClass.self, from: data) + self.init(azorubine: me.azorubine, choroiditis: me.choroiditis, coagulatory: me.coagulatory, cyclorama: me.cyclorama, dolphus: me.dolphus, duckhearted: me.duckhearted, ficus: me.ficus, gemaric: me.gemaric, jugation: me.jugation, myoliposis: me.myoliposis, nonnomination: me.nonnomination, palay: me.palay, pentactinal: me.pentactinal, phaet: me.phaet, piquant: me.piquant, registration: me.registration, remancipation: me.remancipation, scutatiform: me.scutatiform, theodolite: me.theodolite, underward: me.underward) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + azorubine: JSONNull?? = nil, + choroiditis: JSONNull?? = nil, + coagulatory: JSONNull?? = nil, + cyclorama: JSONNull?? = nil, + dolphus: JSONNull?? = nil, + duckhearted: JSONNull?? = nil, + ficus: JSONNull?? = nil, + gemaric: JSONNull?? = nil, + jugation: JSONNull?? = nil, + myoliposis: JSONNull?? = nil, + nonnomination: JSONNull?? = nil, + palay: JSONNull?? = nil, + pentactinal: JSONNull?? = nil, + phaet: JSONNull?? = nil, + piquant: JSONNull?? = nil, + registration: JSONNull?? = nil, + remancipation: JSONNull?? = nil, + scutatiform: JSONNull?? = nil, + theodolite: JSONNull?? = nil, + underward: JSONNull?? = nil + ) -> PrefreshmanClass { + return PrefreshmanClass( + azorubine: azorubine ?? self.azorubine, + choroiditis: choroiditis ?? self.choroiditis, + coagulatory: coagulatory ?? self.coagulatory, + cyclorama: cyclorama ?? self.cyclorama, + dolphus: dolphus ?? self.dolphus, + duckhearted: duckhearted ?? self.duckhearted, + ficus: ficus ?? self.ficus, + gemaric: gemaric ?? self.gemaric, + jugation: jugation ?? self.jugation, + myoliposis: myoliposis ?? self.myoliposis, + nonnomination: nonnomination ?? self.nonnomination, + palay: palay ?? self.palay, + pentactinal: pentactinal ?? self.pentactinal, + phaet: phaet ?? self.phaet, + piquant: piquant ?? self.piquant, + registration: registration ?? self.registration, + remancipation: remancipation ?? self.remancipation, + scutatiform: scutatiform ?? self.scutatiform, + theodolite: theodolite ?? self.theodolite, + underward: underward ?? self.underward + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Prehensility: Codable { + case bool(Bool) + case monaziteClass(MonaziteClass) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Prehensility.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Prehensility")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Prevoidance: Codable { + case integer(Int) + case integerArray([Int]) + case monaziteClass(MonaziteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Prevoidance.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Prevoidance")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + } + } +} + +enum Protext: Codable { + case bool(Bool) + case integerArray([Int]) + case monaziteClass(MonaziteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Protext.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Protext")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + } + } +} + +// MARK: - Helper functions for creating encoders and decoders + +func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder +} + +func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// MARK: - Encode/decode helpers + +final class JSONNull: Codable, Hashable { + + public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool { + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(0) + } + + public init() {} + + public required init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if !container.decodeNil() { + throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull")) + } + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + try container.encodeNil() + } +} diff --git a/head/swift/test/inputs/json/priority/combinations3.json/protocol-hashable--739b516c7897/quicktype.swift b/head/swift/test/inputs/json/priority/combinations3.json/protocol-hashable--739b516c7897/quicktype.swift new file mode 100644 index 0000000..0d99745 --- /dev/null +++ b/head/swift/test/inputs/json/priority/combinations3.json/protocol-hashable--739b516c7897/quicktype.swift @@ -0,0 +1,3227 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +import Foundation + +// MARK: - TopLevel +struct TopLevel: Codable, Hashable { + let juror: [JurorElement] + let kongoni: [Kongoni] + let ladronism: [LadronismElement] + let landlubberly: [LandlubberlyElement] + let listener: [Listener] + let lupus: [LupusElement] + let maslin: [Maslin] + let monazite: [MonaziteElement] + let monoliteral: [Monoliteral] + let monotheistically: [MonotheisticallyElement] + let montage: [Montage] + let moralness: [Moralness] + let mowra: [MonaziteClass?] + let mulishly: [Mulishly] + let myoscope: [Myoscope] + let nach: [[Int?]?] + let neuromastic: [Neuromastic] + let noncontributing: [Noncontributing] + let nonnervous: [Nonnervous] + let nonvaluation: [Nonvaluation] + let occupationalist: [OccupationalistElement] + let outrival: [OutrivalElement] + let paleographically: [Paleographically] + let pamphletwise: [Pamphletwise] + let pediatrics: [Pediatric] + let perceptive: [Bool] + let piaculum: [PiaculumElement] + let piccadilly: [Piccadilly] + let piffler: [Piffler] + let pithful: [Pithful] + let placuntitis: [Placuntiti] + let plectopterous: [Plectopterous] + let pneumocele: [Pneumocele?] + let poliorcetic: [Poliorcetic] + let poormaster: [Poormaster] + let potwhisky: [PotwhiskyElement] + let practicalizer: [Practicalizer] + let prefreshman: [PrefreshmanElement] + let prehensility: [Prehensility] + let prevoidance: [Prevoidance] + let probant: [[String: Int?]] + let protext: [Protext] + + enum CodingKeys: String, CodingKey { + case juror = "juror" + case kongoni = "kongoni" + case ladronism = "ladronism" + case landlubberly = "landlubberly" + case listener = "listener" + case lupus = "lupus" + case maslin = "maslin" + case monazite = "monazite" + case monoliteral = "monoliteral" + case monotheistically = "monotheistically" + case montage = "montage" + case moralness = "moralness" + case mowra = "mowra" + case mulishly = "mulishly" + case myoscope = "myoscope" + case nach = "nach" + case neuromastic = "neuromastic" + case noncontributing = "noncontributing" + case nonnervous = "nonnervous" + case nonvaluation = "nonvaluation" + case occupationalist = "occupationalist" + case outrival = "outrival" + case paleographically = "paleographically" + case pamphletwise = "pamphletwise" + case pediatrics = "pediatrics" + case perceptive = "perceptive" + case piaculum = "piaculum" + case piccadilly = "piccadilly" + case piffler = "piffler" + case pithful = "pithful" + case placuntitis = "placuntitis" + case plectopterous = "plectopterous" + case pneumocele = "pneumocele" + case poliorcetic = "poliorcetic" + case poormaster = "poormaster" + case potwhisky = "potwhisky" + case practicalizer = "practicalizer" + case prefreshman = "prefreshman" + case prehensility = "prehensility" + case prevoidance = "prevoidance" + case probant = "probant" + case protext = "protext" + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + init(data: Data) throws { + self = try newJSONDecoder().decode(TopLevel.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + juror: [JurorElement]? = nil, + kongoni: [Kongoni]? = nil, + ladronism: [LadronismElement]? = nil, + landlubberly: [LandlubberlyElement]? = nil, + listener: [Listener]? = nil, + lupus: [LupusElement]? = nil, + maslin: [Maslin]? = nil, + monazite: [MonaziteElement]? = nil, + monoliteral: [Monoliteral]? = nil, + monotheistically: [MonotheisticallyElement]? = nil, + montage: [Montage]? = nil, + moralness: [Moralness]? = nil, + mowra: [MonaziteClass?]? = nil, + mulishly: [Mulishly]? = nil, + myoscope: [Myoscope]? = nil, + nach: [[Int?]?]? = nil, + neuromastic: [Neuromastic]? = nil, + noncontributing: [Noncontributing]? = nil, + nonnervous: [Nonnervous]? = nil, + nonvaluation: [Nonvaluation]? = nil, + occupationalist: [OccupationalistElement]? = nil, + outrival: [OutrivalElement]? = nil, + paleographically: [Paleographically]? = nil, + pamphletwise: [Pamphletwise]? = nil, + pediatrics: [Pediatric]? = nil, + perceptive: [Bool]? = nil, + piaculum: [PiaculumElement]? = nil, + piccadilly: [Piccadilly]? = nil, + piffler: [Piffler]? = nil, + pithful: [Pithful]? = nil, + placuntitis: [Placuntiti]? = nil, + plectopterous: [Plectopterous]? = nil, + pneumocele: [Pneumocele?]? = nil, + poliorcetic: [Poliorcetic]? = nil, + poormaster: [Poormaster]? = nil, + potwhisky: [PotwhiskyElement]? = nil, + practicalizer: [Practicalizer]? = nil, + prefreshman: [PrefreshmanElement]? = nil, + prehensility: [Prehensility]? = nil, + prevoidance: [Prevoidance]? = nil, + probant: [[String: Int?]]? = nil, + protext: [Protext]? = nil + ) -> TopLevel { + return TopLevel( + juror: juror ?? self.juror, + kongoni: kongoni ?? self.kongoni, + ladronism: ladronism ?? self.ladronism, + landlubberly: landlubberly ?? self.landlubberly, + listener: listener ?? self.listener, + lupus: lupus ?? self.lupus, + maslin: maslin ?? self.maslin, + monazite: monazite ?? self.monazite, + monoliteral: monoliteral ?? self.monoliteral, + monotheistically: monotheistically ?? self.monotheistically, + montage: montage ?? self.montage, + moralness: moralness ?? self.moralness, + mowra: mowra ?? self.mowra, + mulishly: mulishly ?? self.mulishly, + myoscope: myoscope ?? self.myoscope, + nach: nach ?? self.nach, + neuromastic: neuromastic ?? self.neuromastic, + noncontributing: noncontributing ?? self.noncontributing, + nonnervous: nonnervous ?? self.nonnervous, + nonvaluation: nonvaluation ?? self.nonvaluation, + occupationalist: occupationalist ?? self.occupationalist, + outrival: outrival ?? self.outrival, + paleographically: paleographically ?? self.paleographically, + pamphletwise: pamphletwise ?? self.pamphletwise, + pediatrics: pediatrics ?? self.pediatrics, + perceptive: perceptive ?? self.perceptive, + piaculum: piaculum ?? self.piaculum, + piccadilly: piccadilly ?? self.piccadilly, + piffler: piffler ?? self.piffler, + pithful: pithful ?? self.pithful, + placuntitis: placuntitis ?? self.placuntitis, + plectopterous: plectopterous ?? self.plectopterous, + pneumocele: pneumocele ?? self.pneumocele, + poliorcetic: poliorcetic ?? self.poliorcetic, + poormaster: poormaster ?? self.poormaster, + potwhisky: potwhisky ?? self.potwhisky, + practicalizer: practicalizer ?? self.practicalizer, + prefreshman: prefreshman ?? self.prefreshman, + prehensility: prehensility ?? self.prehensility, + prevoidance: prevoidance ?? self.prevoidance, + probant: probant ?? self.probant, + protext: protext ?? self.protext + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum JurorElement: Codable, Hashable { + case bool(Bool) + case jurorClass(JurorClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(JurorClass.self) { + self = .jurorClass(x) + return + } + throw DecodingError.typeMismatch(JurorElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JurorElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .jurorClass(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - JurorClass +struct JurorClass: Codable, Hashable { + let adipsy: JSONNull? + let auxiliator: JSONNull? + let benda: JSONNull? + let benjamin: JSONNull? + let brandling: JSONNull? + let epicurishly: JSONNull? + let eremochaetous: JSONNull? + let marten: JSONNull? + let monocline: JSONNull? + let olea: JSONNull? + let palgat: JSONNull? + let pennyworth: JSONNull? + let pioury: JSONNull? + let pragmatistic: JSONNull? + let stylelessness: JSONNull? + let systematical: JSONNull? + let thready: JSONNull? + let uncontemporary: JSONNull? + let uncouched: JSONNull? + let uninhabitedness: JSONNull? + + enum CodingKeys: String, CodingKey { + case adipsy = "adipsy" + case auxiliator = "auxiliator" + case benda = "benda" + case benjamin = "benjamin" + case brandling = "brandling" + case epicurishly = "epicurishly" + case eremochaetous = "eremochaetous" + case marten = "marten" + case monocline = "monocline" + case olea = "Olea" + case palgat = "palgat" + case pennyworth = "pennyworth" + case pioury = "pioury" + case pragmatistic = "pragmatistic" + case stylelessness = "stylelessness" + case systematical = "systematical" + case thready = "thready" + case uncontemporary = "uncontemporary" + case uncouched = "uncouched" + case uninhabitedness = "uninhabitedness" + } +} + +// MARK: JurorClass convenience initializers and mutators + +extension JurorClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(JurorClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + adipsy: JSONNull?? = nil, + auxiliator: JSONNull?? = nil, + benda: JSONNull?? = nil, + benjamin: JSONNull?? = nil, + brandling: JSONNull?? = nil, + epicurishly: JSONNull?? = nil, + eremochaetous: JSONNull?? = nil, + marten: JSONNull?? = nil, + monocline: JSONNull?? = nil, + olea: JSONNull?? = nil, + palgat: JSONNull?? = nil, + pennyworth: JSONNull?? = nil, + pioury: JSONNull?? = nil, + pragmatistic: JSONNull?? = nil, + stylelessness: JSONNull?? = nil, + systematical: JSONNull?? = nil, + thready: JSONNull?? = nil, + uncontemporary: JSONNull?? = nil, + uncouched: JSONNull?? = nil, + uninhabitedness: JSONNull?? = nil + ) -> JurorClass { + return JurorClass( + adipsy: adipsy ?? self.adipsy, + auxiliator: auxiliator ?? self.auxiliator, + benda: benda ?? self.benda, + benjamin: benjamin ?? self.benjamin, + brandling: brandling ?? self.brandling, + epicurishly: epicurishly ?? self.epicurishly, + eremochaetous: eremochaetous ?? self.eremochaetous, + marten: marten ?? self.marten, + monocline: monocline ?? self.monocline, + olea: olea ?? self.olea, + palgat: palgat ?? self.palgat, + pennyworth: pennyworth ?? self.pennyworth, + pioury: pioury ?? self.pioury, + pragmatistic: pragmatistic ?? self.pragmatistic, + stylelessness: stylelessness ?? self.stylelessness, + systematical: systematical ?? self.systematical, + thready: thready ?? self.thready, + uncontemporary: uncontemporary ?? self.uncontemporary, + uncouched: uncouched ?? self.uncouched, + uninhabitedness: uninhabitedness ?? self.uninhabitedness + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Kongoni: Codable, Hashable { + case integerArray([Int]) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Kongoni.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Kongoni")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum LadronismElement: Codable, Hashable { + case double(Double) + case ladronismClass(LadronismClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(LadronismClass.self) { + self = .ladronismClass(x) + return + } + throw DecodingError.typeMismatch(LadronismElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LadronismElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .ladronismClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - LadronismClass +struct LadronismClass: Codable, Hashable { + let acclaimer: JSONNull? + let achree: JSONNull? + let base: JSONNull? + let conundrumize: JSONNull? + let degerminator: JSONNull? + let describable: JSONNull? + let exasperatedly: JSONNull? + let heroine: JSONNull? + let indazin: JSONNull? + let luteous: JSONNull? + let papular: JSONNull? + let pritch: JSONNull? + let prodenia: JSONNull? + let seege: JSONNull? + let shopgirl: JSONNull? + let tragedietta: JSONNull? + let unsparse: JSONNull? + let uplook: JSONNull? + let vermiformis: JSONNull? + let whafabout: JSONNull? + + enum CodingKeys: String, CodingKey { + case acclaimer = "acclaimer" + case achree = "achree" + case base = "base" + case conundrumize = "conundrumize" + case degerminator = "degerminator" + case describable = "describable" + case exasperatedly = "exasperatedly" + case heroine = "heroine" + case indazin = "indazin" + case luteous = "luteous" + case papular = "papular" + case pritch = "pritch" + case prodenia = "Prodenia" + case seege = "seege" + case shopgirl = "shopgirl" + case tragedietta = "tragedietta" + case unsparse = "unsparse" + case uplook = "uplook" + case vermiformis = "vermiformis" + case whafabout = "whafabout" + } +} + +// MARK: LadronismClass convenience initializers and mutators + +extension LadronismClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(LadronismClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acclaimer: JSONNull?? = nil, + achree: JSONNull?? = nil, + base: JSONNull?? = nil, + conundrumize: JSONNull?? = nil, + degerminator: JSONNull?? = nil, + describable: JSONNull?? = nil, + exasperatedly: JSONNull?? = nil, + heroine: JSONNull?? = nil, + indazin: JSONNull?? = nil, + luteous: JSONNull?? = nil, + papular: JSONNull?? = nil, + pritch: JSONNull?? = nil, + prodenia: JSONNull?? = nil, + seege: JSONNull?? = nil, + shopgirl: JSONNull?? = nil, + tragedietta: JSONNull?? = nil, + unsparse: JSONNull?? = nil, + uplook: JSONNull?? = nil, + vermiformis: JSONNull?? = nil, + whafabout: JSONNull?? = nil + ) -> LadronismClass { + return LadronismClass( + acclaimer: acclaimer ?? self.acclaimer, + achree: achree ?? self.achree, + base: base ?? self.base, + conundrumize: conundrumize ?? self.conundrumize, + degerminator: degerminator ?? self.degerminator, + describable: describable ?? self.describable, + exasperatedly: exasperatedly ?? self.exasperatedly, + heroine: heroine ?? self.heroine, + indazin: indazin ?? self.indazin, + luteous: luteous ?? self.luteous, + papular: papular ?? self.papular, + pritch: pritch ?? self.pritch, + prodenia: prodenia ?? self.prodenia, + seege: seege ?? self.seege, + shopgirl: shopgirl ?? self.shopgirl, + tragedietta: tragedietta ?? self.tragedietta, + unsparse: unsparse ?? self.unsparse, + uplook: uplook ?? self.uplook, + vermiformis: vermiformis ?? self.vermiformis, + whafabout: whafabout ?? self.whafabout + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum LandlubberlyElement: Codable, Hashable { + case bool(Bool) + case integer(Int) + case landlubberlyClass(LandlubberlyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(LandlubberlyClass.self) { + self = .landlubberlyClass(x) + return + } + throw DecodingError.typeMismatch(LandlubberlyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LandlubberlyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .landlubberlyClass(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - LandlubberlyClass +struct LandlubberlyClass: Codable, Hashable { + let acropoleis: JSONNull? + let aminate: JSONNull? + let amyraldism: JSONNull? + let bipenniform: JSONNull? + let bugre: JSONNull? + let calycule: JSONNull? + let caoutchouc: JSONNull? + let disprover: JSONNull? + let fitroot: JSONNull? + let fulgently: JSONNull? + let kickup: JSONNull? + let laevoversion: JSONNull? + let moter: JSONNull? + let objectivity: JSONNull? + let posterity: JSONNull? + let postnuptial: JSONNull? + let precedentary: JSONNull? + let saddling: JSONNull? + let subcurrent: JSONNull? + let unrecriminative: JSONNull? + + enum CodingKeys: String, CodingKey { + case acropoleis = "acropoleis" + case aminate = "aminate" + case amyraldism = "Amyraldism" + case bipenniform = "bipenniform" + case bugre = "bugre" + case calycule = "calycule" + case caoutchouc = "caoutchouc" + case disprover = "disprover" + case fitroot = "fitroot" + case fulgently = "fulgently" + case kickup = "kickup" + case laevoversion = "laevoversion" + case moter = "moter" + case objectivity = "objectivity" + case posterity = "posterity" + case postnuptial = "postnuptial" + case precedentary = "precedentary" + case saddling = "saddling" + case subcurrent = "subcurrent" + case unrecriminative = "unrecriminative" + } +} + +// MARK: LandlubberlyClass convenience initializers and mutators + +extension LandlubberlyClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(LandlubberlyClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acropoleis: JSONNull?? = nil, + aminate: JSONNull?? = nil, + amyraldism: JSONNull?? = nil, + bipenniform: JSONNull?? = nil, + bugre: JSONNull?? = nil, + calycule: JSONNull?? = nil, + caoutchouc: JSONNull?? = nil, + disprover: JSONNull?? = nil, + fitroot: JSONNull?? = nil, + fulgently: JSONNull?? = nil, + kickup: JSONNull?? = nil, + laevoversion: JSONNull?? = nil, + moter: JSONNull?? = nil, + objectivity: JSONNull?? = nil, + posterity: JSONNull?? = nil, + postnuptial: JSONNull?? = nil, + precedentary: JSONNull?? = nil, + saddling: JSONNull?? = nil, + subcurrent: JSONNull?? = nil, + unrecriminative: JSONNull?? = nil + ) -> LandlubberlyClass { + return LandlubberlyClass( + acropoleis: acropoleis ?? self.acropoleis, + aminate: aminate ?? self.aminate, + amyraldism: amyraldism ?? self.amyraldism, + bipenniform: bipenniform ?? self.bipenniform, + bugre: bugre ?? self.bugre, + calycule: calycule ?? self.calycule, + caoutchouc: caoutchouc ?? self.caoutchouc, + disprover: disprover ?? self.disprover, + fitroot: fitroot ?? self.fitroot, + fulgently: fulgently ?? self.fulgently, + kickup: kickup ?? self.kickup, + laevoversion: laevoversion ?? self.laevoversion, + moter: moter ?? self.moter, + objectivity: objectivity ?? self.objectivity, + posterity: posterity ?? self.posterity, + postnuptial: postnuptial ?? self.postnuptial, + precedentary: precedentary ?? self.precedentary, + saddling: saddling ?? self.saddling, + subcurrent: subcurrent ?? self.subcurrent, + unrecriminative: unrecriminative ?? self.unrecriminative + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Listener: Codable, Hashable { + case integer(Int) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + throw DecodingError.typeMismatch(Listener.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Listener")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum LupusElement: Codable, Hashable { + case integer(Int) + case lupusClass(LupusClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(LupusClass.self) { + self = .lupusClass(x) + return + } + throw DecodingError.typeMismatch(LupusElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for LupusElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .lupusClass(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - LupusClass +struct LupusClass: Codable, Hashable { + let catharticalness: Double? + let chirotherium: Int? + let chlorioninae: Int? + let corvinae: Int? + let crassina: Int? + let disdiapason: String? + let exiguity: Int? + let farcist: Int? + let holographical: Int? + let homocerc: Bool? + let ichthyophagan: Int? + let implacable: Int? + let nonbookish: JSONNull? + let outshiner: Int? + let overweather: Int? + let protonegroid: Int? + let shallowish: Int? + let snoke: Int? + let snout: Int? + let surveillance: Int? + let threshingtime: Int? + let thysanocarpus: Int? + let unsignificantly: Int? + let unsnap: Int? + let vendible: Int? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case chlorioninae = "Chlorioninae" + case corvinae = "Corvinae" + case crassina = "Crassina" + case disdiapason = "disdiapason" + case exiguity = "exiguity" + case farcist = "farcist" + case holographical = "holographical" + case homocerc = "homocerc" + case ichthyophagan = "ichthyophagan" + case implacable = "implacable" + case nonbookish = "nonbookish" + case outshiner = "outshiner" + case overweather = "overweather" + case protonegroid = "protonegroid" + case shallowish = "shallowish" + case snoke = "snoke" + case snout = "snout" + case surveillance = "surveillance" + case threshingtime = "threshingtime" + case thysanocarpus = "Thysanocarpus" + case unsignificantly = "unsignificantly" + case unsnap = "unsnap" + case vendible = "vendible" + } +} + +// MARK: LupusClass convenience initializers and mutators + +extension LupusClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(LupusClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + chlorioninae: Int?? = nil, + corvinae: Int?? = nil, + crassina: Int?? = nil, + disdiapason: String?? = nil, + exiguity: Int?? = nil, + farcist: Int?? = nil, + holographical: Int?? = nil, + homocerc: Bool?? = nil, + ichthyophagan: Int?? = nil, + implacable: Int?? = nil, + nonbookish: JSONNull?? = nil, + outshiner: Int?? = nil, + overweather: Int?? = nil, + protonegroid: Int?? = nil, + shallowish: Int?? = nil, + snoke: Int?? = nil, + snout: Int?? = nil, + surveillance: Int?? = nil, + threshingtime: Int?? = nil, + thysanocarpus: Int?? = nil, + unsignificantly: Int?? = nil, + unsnap: Int?? = nil, + vendible: Int?? = nil + ) -> LupusClass { + return LupusClass( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + chlorioninae: chlorioninae ?? self.chlorioninae, + corvinae: corvinae ?? self.corvinae, + crassina: crassina ?? self.crassina, + disdiapason: disdiapason ?? self.disdiapason, + exiguity: exiguity ?? self.exiguity, + farcist: farcist ?? self.farcist, + holographical: holographical ?? self.holographical, + homocerc: homocerc ?? self.homocerc, + ichthyophagan: ichthyophagan ?? self.ichthyophagan, + implacable: implacable ?? self.implacable, + nonbookish: nonbookish ?? self.nonbookish, + outshiner: outshiner ?? self.outshiner, + overweather: overweather ?? self.overweather, + protonegroid: protonegroid ?? self.protonegroid, + shallowish: shallowish ?? self.shallowish, + snoke: snoke ?? self.snoke, + snout: snout ?? self.snout, + surveillance: surveillance ?? self.surveillance, + threshingtime: threshingtime ?? self.threshingtime, + thysanocarpus: thysanocarpus ?? self.thysanocarpus, + unsignificantly: unsignificantly ?? self.unsignificantly, + unsnap: unsnap ?? self.unsnap, + vendible: vendible ?? self.vendible + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - Maslin +struct Maslin: Codable, Hashable { + let alicant: Int? + let antiatonement: JSONNull? + let anticorrosive: Int? + let aphidozer: JSONNull? + let bakuninist: JSONNull? + let be: Int? + let catharticalness: Double? + let chirotherium: Int? + let chub: Int? + let cuprosilicon: Int? + let curtailedly: Int? + let dellenite: Int? + let dimitry: Int? + let disdiapason: String? + let edifying: JSONNull? + let ethmoiditis: Int? + let gastralgy: JSONNull? + let goatherd: Int? + let hammerdress: Int? + let hangfire: JSONNull? + let homocerc: Bool? + let lacunosity: Int? + let longiloquence: JSONNull? + let mameliere: Int? + let motherless: JSONNull? + let nonbookish: JSONNull? + let noncorrodible: JSONNull? + let nonsensicality: JSONNull? + let oafishly: Int? + let pfund: JSONNull? + let preadvisory: JSONNull? + let retroflexed: JSONNull? + let saccharulmic: Int? + let scowlful: Int? + let secluded: JSONNull? + let slackage: JSONNull? + let sphaeridial: Int? + let spondulics: JSONNull? + let subsecive: Int? + let swellmobsman: JSONNull? + let trachyglossate: Int? + let trialogue: JSONNull? + let unassuaged: Int? + let ungross: JSONNull? + let unjudiciously: JSONNull? + + enum CodingKeys: String, CodingKey { + case alicant = "Alicant" + case antiatonement = "antiatonement" + case anticorrosive = "anticorrosive" + case aphidozer = "aphidozer" + case bakuninist = "Bakuninist" + case be = "be" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case chub = "chub" + case cuprosilicon = "cuprosilicon" + case curtailedly = "curtailedly" + case dellenite = "dellenite" + case dimitry = "Dimitry" + case disdiapason = "disdiapason" + case edifying = "edifying" + case ethmoiditis = "ethmoiditis" + case gastralgy = "gastralgy" + case goatherd = "goatherd" + case hammerdress = "hammerdress" + case hangfire = "hangfire" + case homocerc = "homocerc" + case lacunosity = "lacunosity" + case longiloquence = "longiloquence" + case mameliere = "mameliere" + case motherless = "motherless" + case nonbookish = "nonbookish" + case noncorrodible = "noncorrodible" + case nonsensicality = "nonsensicality" + case oafishly = "oafishly" + case pfund = "pfund" + case preadvisory = "preadvisory" + case retroflexed = "retroflexed" + case saccharulmic = "saccharulmic" + case scowlful = "scowlful" + case secluded = "secluded" + case slackage = "slackage" + case sphaeridial = "sphaeridial" + case spondulics = "spondulics" + case subsecive = "subsecive" + case swellmobsman = "swellmobsman" + case trachyglossate = "trachyglossate" + case trialogue = "trialogue" + case unassuaged = "unassuaged" + case ungross = "ungross" + case unjudiciously = "unjudiciously" + } +} + +// MARK: Maslin convenience initializers and mutators + +extension Maslin { + init(data: Data) throws { + self = try newJSONDecoder().decode(Maslin.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + alicant: Int?? = nil, + antiatonement: JSONNull?? = nil, + anticorrosive: Int?? = nil, + aphidozer: JSONNull?? = nil, + bakuninist: JSONNull?? = nil, + be: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + chub: Int?? = nil, + cuprosilicon: Int?? = nil, + curtailedly: Int?? = nil, + dellenite: Int?? = nil, + dimitry: Int?? = nil, + disdiapason: String?? = nil, + edifying: JSONNull?? = nil, + ethmoiditis: Int?? = nil, + gastralgy: JSONNull?? = nil, + goatherd: Int?? = nil, + hammerdress: Int?? = nil, + hangfire: JSONNull?? = nil, + homocerc: Bool?? = nil, + lacunosity: Int?? = nil, + longiloquence: JSONNull?? = nil, + mameliere: Int?? = nil, + motherless: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + noncorrodible: JSONNull?? = nil, + nonsensicality: JSONNull?? = nil, + oafishly: Int?? = nil, + pfund: JSONNull?? = nil, + preadvisory: JSONNull?? = nil, + retroflexed: JSONNull?? = nil, + saccharulmic: Int?? = nil, + scowlful: Int?? = nil, + secluded: JSONNull?? = nil, + slackage: JSONNull?? = nil, + sphaeridial: Int?? = nil, + spondulics: JSONNull?? = nil, + subsecive: Int?? = nil, + swellmobsman: JSONNull?? = nil, + trachyglossate: Int?? = nil, + trialogue: JSONNull?? = nil, + unassuaged: Int?? = nil, + ungross: JSONNull?? = nil, + unjudiciously: JSONNull?? = nil + ) -> Maslin { + return Maslin( + alicant: alicant ?? self.alicant, + antiatonement: antiatonement ?? self.antiatonement, + anticorrosive: anticorrosive ?? self.anticorrosive, + aphidozer: aphidozer ?? self.aphidozer, + bakuninist: bakuninist ?? self.bakuninist, + be: be ?? self.be, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + chub: chub ?? self.chub, + cuprosilicon: cuprosilicon ?? self.cuprosilicon, + curtailedly: curtailedly ?? self.curtailedly, + dellenite: dellenite ?? self.dellenite, + dimitry: dimitry ?? self.dimitry, + disdiapason: disdiapason ?? self.disdiapason, + edifying: edifying ?? self.edifying, + ethmoiditis: ethmoiditis ?? self.ethmoiditis, + gastralgy: gastralgy ?? self.gastralgy, + goatherd: goatherd ?? self.goatherd, + hammerdress: hammerdress ?? self.hammerdress, + hangfire: hangfire ?? self.hangfire, + homocerc: homocerc ?? self.homocerc, + lacunosity: lacunosity ?? self.lacunosity, + longiloquence: longiloquence ?? self.longiloquence, + mameliere: mameliere ?? self.mameliere, + motherless: motherless ?? self.motherless, + nonbookish: nonbookish ?? self.nonbookish, + noncorrodible: noncorrodible ?? self.noncorrodible, + nonsensicality: nonsensicality ?? self.nonsensicality, + oafishly: oafishly ?? self.oafishly, + pfund: pfund ?? self.pfund, + preadvisory: preadvisory ?? self.preadvisory, + retroflexed: retroflexed ?? self.retroflexed, + saccharulmic: saccharulmic ?? self.saccharulmic, + scowlful: scowlful ?? self.scowlful, + secluded: secluded ?? self.secluded, + slackage: slackage ?? self.slackage, + sphaeridial: sphaeridial ?? self.sphaeridial, + spondulics: spondulics ?? self.spondulics, + subsecive: subsecive ?? self.subsecive, + swellmobsman: swellmobsman ?? self.swellmobsman, + trachyglossate: trachyglossate ?? self.trachyglossate, + trialogue: trialogue ?? self.trialogue, + unassuaged: unassuaged ?? self.unassuaged, + ungross: ungross ?? self.ungross, + unjudiciously: unjudiciously ?? self.unjudiciously + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum MonaziteElement: Codable, Hashable { + case double(Double) + case monaziteClass(MonaziteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(MonaziteElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for MonaziteElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - MonaziteClass +struct MonaziteClass: Codable, Hashable { + let catharticalness: Double + let chirotherium: Int + let disdiapason: String + let homocerc: Bool + let nonbookish: JSONNull? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case homocerc = "homocerc" + case nonbookish = "nonbookish" + } +} + +// MARK: MonaziteClass convenience initializers and mutators + +extension MonaziteClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(MonaziteClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double? = nil, + chirotherium: Int? = nil, + disdiapason: String? = nil, + homocerc: Bool? = nil, + nonbookish: JSONNull?? = nil + ) -> MonaziteClass { + return MonaziteClass( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + homocerc: homocerc ?? self.homocerc, + nonbookish: nonbookish ?? self.nonbookish + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Monoliteral: Codable, Hashable { + case bool(Bool) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + throw DecodingError.typeMismatch(Monoliteral.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Monoliteral")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum MonotheisticallyElement: Codable, Hashable { + case monotheisticallyClass(MonotheisticallyClass) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(MonotheisticallyClass.self) { + self = .monotheisticallyClass(x) + return + } + throw DecodingError.typeMismatch(MonotheisticallyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for MonotheisticallyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .monotheisticallyClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - MonotheisticallyClass +struct MonotheisticallyClass: Codable, Hashable { + let blaspheme: JSONNull? + let catharticalness: Double? + let celiosalpingectomy: JSONNull? + let chirotherium: Int? + let consummativeness: JSONNull? + let disdiapason: String? + let egestive: JSONNull? + let enchylema: JSONNull? + let gasconade: JSONNull? + let holidayer: JSONNull? + let homocerc: Bool? + let intuitionalism: JSONNull? + let lophiostomate: JSONNull? + let nonbookish: JSONNull? + let nonvolition: JSONNull? + let palatableness: JSONNull? + let pimpery: JSONNull? + let previolation: JSONNull? + let reconveyance: JSONNull? + let registership: JSONNull? + let rhyacolite: JSONNull? + let smithereens: JSONNull? + let superedification: JSONNull? + let trust: JSONNull? + let whitestone: JSONNull? + + enum CodingKeys: String, CodingKey { + case blaspheme = "blaspheme" + case catharticalness = "catharticalness" + case celiosalpingectomy = "celiosalpingectomy" + case chirotherium = "Chirotherium" + case consummativeness = "consummativeness" + case disdiapason = "disdiapason" + case egestive = "egestive" + case enchylema = "enchylema" + case gasconade = "gasconade" + case holidayer = "holidayer" + case homocerc = "homocerc" + case intuitionalism = "intuitionalism" + case lophiostomate = "lophiostomate" + case nonbookish = "nonbookish" + case nonvolition = "nonvolition" + case palatableness = "palatableness" + case pimpery = "pimpery" + case previolation = "previolation" + case reconveyance = "reconveyance" + case registership = "registership" + case rhyacolite = "rhyacolite" + case smithereens = "smithereens" + case superedification = "superedification" + case trust = "trust" + case whitestone = "whitestone" + } +} + +// MARK: MonotheisticallyClass convenience initializers and mutators + +extension MonotheisticallyClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(MonotheisticallyClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + blaspheme: JSONNull?? = nil, + catharticalness: Double?? = nil, + celiosalpingectomy: JSONNull?? = nil, + chirotherium: Int?? = nil, + consummativeness: JSONNull?? = nil, + disdiapason: String?? = nil, + egestive: JSONNull?? = nil, + enchylema: JSONNull?? = nil, + gasconade: JSONNull?? = nil, + holidayer: JSONNull?? = nil, + homocerc: Bool?? = nil, + intuitionalism: JSONNull?? = nil, + lophiostomate: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + nonvolition: JSONNull?? = nil, + palatableness: JSONNull?? = nil, + pimpery: JSONNull?? = nil, + previolation: JSONNull?? = nil, + reconveyance: JSONNull?? = nil, + registership: JSONNull?? = nil, + rhyacolite: JSONNull?? = nil, + smithereens: JSONNull?? = nil, + superedification: JSONNull?? = nil, + trust: JSONNull?? = nil, + whitestone: JSONNull?? = nil + ) -> MonotheisticallyClass { + return MonotheisticallyClass( + blaspheme: blaspheme ?? self.blaspheme, + catharticalness: catharticalness ?? self.catharticalness, + celiosalpingectomy: celiosalpingectomy ?? self.celiosalpingectomy, + chirotherium: chirotherium ?? self.chirotherium, + consummativeness: consummativeness ?? self.consummativeness, + disdiapason: disdiapason ?? self.disdiapason, + egestive: egestive ?? self.egestive, + enchylema: enchylema ?? self.enchylema, + gasconade: gasconade ?? self.gasconade, + holidayer: holidayer ?? self.holidayer, + homocerc: homocerc ?? self.homocerc, + intuitionalism: intuitionalism ?? self.intuitionalism, + lophiostomate: lophiostomate ?? self.lophiostomate, + nonbookish: nonbookish ?? self.nonbookish, + nonvolition: nonvolition ?? self.nonvolition, + palatableness: palatableness ?? self.palatableness, + pimpery: pimpery ?? self.pimpery, + previolation: previolation ?? self.previolation, + reconveyance: reconveyance ?? self.reconveyance, + registership: registership ?? self.registership, + rhyacolite: rhyacolite ?? self.rhyacolite, + smithereens: smithereens ?? self.smithereens, + superedification: superedification ?? self.superedification, + trust: trust ?? self.trust, + whitestone: whitestone ?? self.whitestone + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Montage: Codable, Hashable { + case double(Double) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Montage.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Montage")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Moralness: Codable, Hashable { + case double(Double) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Moralness.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Moralness")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Mulishly: Codable, Hashable { + case double(Double) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Mulishly.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Mulishly")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Myoscope: Codable, Hashable { + case bool(Bool) + case integer(Int) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + throw DecodingError.typeMismatch(Myoscope.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Myoscope")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Neuromastic: Codable, Hashable { + case double(Double) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Neuromastic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Neuromastic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - Noncontributing +struct Noncontributing: Codable, Hashable { + let estevin: String + let jolterhead: Double + let sauternes: Int + let sparsely: Bool + let unrequested: JSONNull? + + enum CodingKeys: String, CodingKey { + case estevin = "estevin" + case jolterhead = "jolterhead" + case sauternes = "sauternes" + case sparsely = "sparsely" + case unrequested = "unrequested" + } +} + +// MARK: Noncontributing convenience initializers and mutators + +extension Noncontributing { + init(data: Data) throws { + self = try newJSONDecoder().decode(Noncontributing.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + estevin: String? = nil, + jolterhead: Double? = nil, + sauternes: Int? = nil, + sparsely: Bool? = nil, + unrequested: JSONNull?? = nil + ) -> Noncontributing { + return Noncontributing( + estevin: estevin ?? self.estevin, + jolterhead: jolterhead ?? self.jolterhead, + sauternes: sauternes ?? self.sauternes, + sparsely: sparsely ?? self.sparsely, + unrequested: unrequested ?? self.unrequested + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Nonnervous: Codable, Hashable { + case bool(Bool) + case integer(Int) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + throw DecodingError.typeMismatch(Nonnervous.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Nonnervous")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + } + } +} + +enum Nonvaluation: Codable, Hashable { + case bool(Bool) + case double(Double) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Nonvaluation.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Nonvaluation")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum OccupationalistElement: Codable, Hashable { + case nullArray([JSONNull?]) + case occupationalistClass(OccupationalistClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(OccupationalistClass.self) { + self = .occupationalistClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(OccupationalistElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for OccupationalistElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .occupationalistClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - OccupationalistClass +struct OccupationalistClass: Codable, Hashable { + let beholdable: JSONNull? + let brotuliform: JSONNull? + let chimakum: JSONNull? + let doodler: JSONNull? + let emulsin: JSONNull? + let fin: JSONNull? + let flourishing: JSONNull? + let flueless: JSONNull? + let furtively: JSONNull? + let gritter: JSONNull? + let interwish: JSONNull? + let monoxylic: JSONNull? + let myristic: JSONNull? + let nightwear: JSONNull? + let peruser: JSONNull? + let theoastrological: JSONNull? + let thumby: JSONNull? + let tingitid: JSONNull? + let trailless: JSONNull? + let unpocketed: JSONNull? + + enum CodingKeys: String, CodingKey { + case beholdable = "beholdable" + case brotuliform = "brotuliform" + case chimakum = "Chimakum" + case doodler = "doodler" + case emulsin = "emulsin" + case fin = "Fin" + case flourishing = "flourishing" + case flueless = "flueless" + case furtively = "furtively" + case gritter = "gritter" + case interwish = "interwish" + case monoxylic = "monoxylic" + case myristic = "myristic" + case nightwear = "nightwear" + case peruser = "peruser" + case theoastrological = "theoastrological" + case thumby = "thumby" + case tingitid = "tingitid" + case trailless = "trailless" + case unpocketed = "unpocketed" + } +} + +// MARK: OccupationalistClass convenience initializers and mutators + +extension OccupationalistClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(OccupationalistClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + beholdable: JSONNull?? = nil, + brotuliform: JSONNull?? = nil, + chimakum: JSONNull?? = nil, + doodler: JSONNull?? = nil, + emulsin: JSONNull?? = nil, + fin: JSONNull?? = nil, + flourishing: JSONNull?? = nil, + flueless: JSONNull?? = nil, + furtively: JSONNull?? = nil, + gritter: JSONNull?? = nil, + interwish: JSONNull?? = nil, + monoxylic: JSONNull?? = nil, + myristic: JSONNull?? = nil, + nightwear: JSONNull?? = nil, + peruser: JSONNull?? = nil, + theoastrological: JSONNull?? = nil, + thumby: JSONNull?? = nil, + tingitid: JSONNull?? = nil, + trailless: JSONNull?? = nil, + unpocketed: JSONNull?? = nil + ) -> OccupationalistClass { + return OccupationalistClass( + beholdable: beholdable ?? self.beholdable, + brotuliform: brotuliform ?? self.brotuliform, + chimakum: chimakum ?? self.chimakum, + doodler: doodler ?? self.doodler, + emulsin: emulsin ?? self.emulsin, + fin: fin ?? self.fin, + flourishing: flourishing ?? self.flourishing, + flueless: flueless ?? self.flueless, + furtively: furtively ?? self.furtively, + gritter: gritter ?? self.gritter, + interwish: interwish ?? self.interwish, + monoxylic: monoxylic ?? self.monoxylic, + myristic: myristic ?? self.myristic, + nightwear: nightwear ?? self.nightwear, + peruser: peruser ?? self.peruser, + theoastrological: theoastrological ?? self.theoastrological, + thumby: thumby ?? self.thumby, + tingitid: tingitid ?? self.tingitid, + trailless: trailless ?? self.trailless, + unpocketed: unpocketed ?? self.unpocketed + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum OutrivalElement: Codable, Hashable { + case double(Double) + case outrivalClass(OutrivalClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(OutrivalClass.self) { + self = .outrivalClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(OutrivalElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for OutrivalElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .outrivalClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - OutrivalClass +struct OutrivalClass: Codable, Hashable { + let adroitly: JSONNull? + let bridehood: JSONNull? + let castoroides: JSONNull? + let czechoslovak: JSONNull? + let diagenesis: JSONNull? + let dihexahedron: JSONNull? + let dopester: JSONNull? + let eumerism: JSONNull? + let flyness: JSONNull? + let fouler: JSONNull? + let laudanosine: JSONNull? + let lingulidae: JSONNull? + let minutary: JSONNull? + let mitra: JSONNull? + let opisthorchiasis: JSONNull? + let pensively: JSONNull? + let pubigerous: JSONNull? + let rebellious: JSONNull? + let recodify: JSONNull? + let unpaced: JSONNull? + + enum CodingKeys: String, CodingKey { + case adroitly = "adroitly" + case bridehood = "bridehood" + case castoroides = "Castoroides" + case czechoslovak = "Czechoslovak" + case diagenesis = "diagenesis" + case dihexahedron = "dihexahedron" + case dopester = "dopester" + case eumerism = "eumerism" + case flyness = "flyness" + case fouler = "fouler" + case laudanosine = "laudanosine" + case lingulidae = "Lingulidae" + case minutary = "minutary" + case mitra = "mitra" + case opisthorchiasis = "opisthorchiasis" + case pensively = "pensively" + case pubigerous = "pubigerous" + case rebellious = "rebellious" + case recodify = "recodify" + case unpaced = "unpaced" + } +} + +// MARK: OutrivalClass convenience initializers and mutators + +extension OutrivalClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(OutrivalClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + adroitly: JSONNull?? = nil, + bridehood: JSONNull?? = nil, + castoroides: JSONNull?? = nil, + czechoslovak: JSONNull?? = nil, + diagenesis: JSONNull?? = nil, + dihexahedron: JSONNull?? = nil, + dopester: JSONNull?? = nil, + eumerism: JSONNull?? = nil, + flyness: JSONNull?? = nil, + fouler: JSONNull?? = nil, + laudanosine: JSONNull?? = nil, + lingulidae: JSONNull?? = nil, + minutary: JSONNull?? = nil, + mitra: JSONNull?? = nil, + opisthorchiasis: JSONNull?? = nil, + pensively: JSONNull?? = nil, + pubigerous: JSONNull?? = nil, + rebellious: JSONNull?? = nil, + recodify: JSONNull?? = nil, + unpaced: JSONNull?? = nil + ) -> OutrivalClass { + return OutrivalClass( + adroitly: adroitly ?? self.adroitly, + bridehood: bridehood ?? self.bridehood, + castoroides: castoroides ?? self.castoroides, + czechoslovak: czechoslovak ?? self.czechoslovak, + diagenesis: diagenesis ?? self.diagenesis, + dihexahedron: dihexahedron ?? self.dihexahedron, + dopester: dopester ?? self.dopester, + eumerism: eumerism ?? self.eumerism, + flyness: flyness ?? self.flyness, + fouler: fouler ?? self.fouler, + laudanosine: laudanosine ?? self.laudanosine, + lingulidae: lingulidae ?? self.lingulidae, + minutary: minutary ?? self.minutary, + mitra: mitra ?? self.mitra, + opisthorchiasis: opisthorchiasis ?? self.opisthorchiasis, + pensively: pensively ?? self.pensively, + pubigerous: pubigerous ?? self.pubigerous, + rebellious: rebellious ?? self.rebellious, + recodify: recodify ?? self.recodify, + unpaced: unpaced ?? self.unpaced + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Paleographically: Codable, Hashable { + case double(Double) + case unionMap([String: Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int?].self) { + self = .unionMap(x) + return + } + throw DecodingError.typeMismatch(Paleographically.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Paleographically")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .unionMap(let x): + try container.encode(x) + } + } +} + +enum Pamphletwise: Codable, Hashable { + case integer(Int) + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Pamphletwise.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Pamphletwise")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Pediatric: Codable, Hashable { + case bool(Bool) + case double(Double) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Pediatric.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Pediatric")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum PiaculumElement: Codable, Hashable { + case double(Double) + case piaculumClass(PiaculumClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(PiaculumClass.self) { + self = .piaculumClass(x) + return + } + throw DecodingError.typeMismatch(PiaculumElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PiaculumElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .piaculumClass(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - PiaculumClass +struct PiaculumClass: Codable, Hashable { + let alada: Int? + let amphistomous: Int? + let boysenberry: Int? + let catharticalness: Double? + let chirotherium: Int? + let decardinalize: Int? + let discouragement: Int? + let disdiapason: String? + let doitrified: Int? + let hexaspermous: Int? + let homocerc: Bool? + let insinking: Int? + let loathfulness: Int? + let miasmatical: Int? + let neurofibril: Int? + let nonbookish: JSONNull? + let phonendoscope: Int? + let pilferment: Int? + let predismissory: Int? + let preinscription: Int? + let quotative: Int? + let sienna: Int? + let thorax: Int? + let yachting: Int? + let zipper: Int? + + enum CodingKeys: String, CodingKey { + case alada = "alada" + case amphistomous = "amphistomous" + case boysenberry = "boysenberry" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case decardinalize = "decardinalize" + case discouragement = "discouragement" + case disdiapason = "disdiapason" + case doitrified = "doitrified" + case hexaspermous = "hexaspermous" + case homocerc = "homocerc" + case insinking = "insinking" + case loathfulness = "loathfulness" + case miasmatical = "miasmatical" + case neurofibril = "neurofibril" + case nonbookish = "nonbookish" + case phonendoscope = "phonendoscope" + case pilferment = "pilferment" + case predismissory = "predismissory" + case preinscription = "preinscription" + case quotative = "quotative" + case sienna = "sienna" + case thorax = "thorax" + case yachting = "yachting" + case zipper = "Zipper" + } +} + +// MARK: PiaculumClass convenience initializers and mutators + +extension PiaculumClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(PiaculumClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + alada: Int?? = nil, + amphistomous: Int?? = nil, + boysenberry: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + decardinalize: Int?? = nil, + discouragement: Int?? = nil, + disdiapason: String?? = nil, + doitrified: Int?? = nil, + hexaspermous: Int?? = nil, + homocerc: Bool?? = nil, + insinking: Int?? = nil, + loathfulness: Int?? = nil, + miasmatical: Int?? = nil, + neurofibril: Int?? = nil, + nonbookish: JSONNull?? = nil, + phonendoscope: Int?? = nil, + pilferment: Int?? = nil, + predismissory: Int?? = nil, + preinscription: Int?? = nil, + quotative: Int?? = nil, + sienna: Int?? = nil, + thorax: Int?? = nil, + yachting: Int?? = nil, + zipper: Int?? = nil + ) -> PiaculumClass { + return PiaculumClass( + alada: alada ?? self.alada, + amphistomous: amphistomous ?? self.amphistomous, + boysenberry: boysenberry ?? self.boysenberry, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + decardinalize: decardinalize ?? self.decardinalize, + discouragement: discouragement ?? self.discouragement, + disdiapason: disdiapason ?? self.disdiapason, + doitrified: doitrified ?? self.doitrified, + hexaspermous: hexaspermous ?? self.hexaspermous, + homocerc: homocerc ?? self.homocerc, + insinking: insinking ?? self.insinking, + loathfulness: loathfulness ?? self.loathfulness, + miasmatical: miasmatical ?? self.miasmatical, + neurofibril: neurofibril ?? self.neurofibril, + nonbookish: nonbookish ?? self.nonbookish, + phonendoscope: phonendoscope ?? self.phonendoscope, + pilferment: pilferment ?? self.pilferment, + predismissory: predismissory ?? self.predismissory, + preinscription: preinscription ?? self.preinscription, + quotative: quotative ?? self.quotative, + sienna: sienna ?? self.sienna, + thorax: thorax ?? self.thorax, + yachting: yachting ?? self.yachting, + zipper: zipper ?? self.zipper + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Piccadilly: Codable, Hashable { + case double(Double) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Piccadilly.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Piccadilly")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Piffler: Codable, Hashable { + case monaziteClass(MonaziteClass) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Piffler.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Piffler")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .monaziteClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Pithful: Codable, Hashable { + case bool(Bool) + case integer(Int) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Pithful.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Pithful")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Placuntiti: Codable, Hashable { + case integer(Int) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Placuntiti.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Placuntiti")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Plectopterous: Codable, Hashable { + case double(Double) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Plectopterous.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Plectopterous")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - Pneumocele +struct Pneumocele: Codable, Hashable { + let carbonarism: JSONNull? + let catharticalness: Double? + let chirotherium: Int? + let cineolic: JSONNull? + let cobbly: JSONNull? + let conchyliferous: JSONNull? + let congregation: JSONNull? + let disdiapason: String? + let enterotomy: JSONNull? + let entophytal: JSONNull? + let fewtrils: JSONNull? + let herem: JSONNull? + let homocerc: Bool? + let koniga: JSONNull? + let meticulosity: JSONNull? + let micky: JSONNull? + let mismarriage: JSONNull? + let neurotrophic: JSONNull? + let nonbookish: JSONNull? + let persuasively: JSONNull? + let replaceable: JSONNull? + let silex: JSONNull? + let taillight: JSONNull? + let unjealous: JSONNull? + let visitorial: JSONNull? + + enum CodingKeys: String, CodingKey { + case carbonarism = "Carbonarism" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case cineolic = "cineolic" + case cobbly = "cobbly" + case conchyliferous = "conchyliferous" + case congregation = "congregation" + case disdiapason = "disdiapason" + case enterotomy = "enterotomy" + case entophytal = "entophytal" + case fewtrils = "fewtrils" + case herem = "herem" + case homocerc = "homocerc" + case koniga = "Koniga" + case meticulosity = "meticulosity" + case micky = "Micky" + case mismarriage = "mismarriage" + case neurotrophic = "neurotrophic" + case nonbookish = "nonbookish" + case persuasively = "persuasively" + case replaceable = "replaceable" + case silex = "silex" + case taillight = "taillight" + case unjealous = "unjealous" + case visitorial = "visitorial" + } +} + +// MARK: Pneumocele convenience initializers and mutators + +extension Pneumocele { + init(data: Data) throws { + self = try newJSONDecoder().decode(Pneumocele.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + carbonarism: JSONNull?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + cineolic: JSONNull?? = nil, + cobbly: JSONNull?? = nil, + conchyliferous: JSONNull?? = nil, + congregation: JSONNull?? = nil, + disdiapason: String?? = nil, + enterotomy: JSONNull?? = nil, + entophytal: JSONNull?? = nil, + fewtrils: JSONNull?? = nil, + herem: JSONNull?? = nil, + homocerc: Bool?? = nil, + koniga: JSONNull?? = nil, + meticulosity: JSONNull?? = nil, + micky: JSONNull?? = nil, + mismarriage: JSONNull?? = nil, + neurotrophic: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + persuasively: JSONNull?? = nil, + replaceable: JSONNull?? = nil, + silex: JSONNull?? = nil, + taillight: JSONNull?? = nil, + unjealous: JSONNull?? = nil, + visitorial: JSONNull?? = nil + ) -> Pneumocele { + return Pneumocele( + carbonarism: carbonarism ?? self.carbonarism, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + cineolic: cineolic ?? self.cineolic, + cobbly: cobbly ?? self.cobbly, + conchyliferous: conchyliferous ?? self.conchyliferous, + congregation: congregation ?? self.congregation, + disdiapason: disdiapason ?? self.disdiapason, + enterotomy: enterotomy ?? self.enterotomy, + entophytal: entophytal ?? self.entophytal, + fewtrils: fewtrils ?? self.fewtrils, + herem: herem ?? self.herem, + homocerc: homocerc ?? self.homocerc, + koniga: koniga ?? self.koniga, + meticulosity: meticulosity ?? self.meticulosity, + micky: micky ?? self.micky, + mismarriage: mismarriage ?? self.mismarriage, + neurotrophic: neurotrophic ?? self.neurotrophic, + nonbookish: nonbookish ?? self.nonbookish, + persuasively: persuasively ?? self.persuasively, + replaceable: replaceable ?? self.replaceable, + silex: silex ?? self.silex, + taillight: taillight ?? self.taillight, + unjealous: unjealous ?? self.unjealous, + visitorial: visitorial ?? self.visitorial + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Poliorcetic: Codable, Hashable { + case bool(Bool) + case monaziteClass(MonaziteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Poliorcetic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Poliorcetic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + } + } +} + +enum Poormaster: Codable, Hashable { + case integerArray([Int]) + case integerMap([String: Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Poormaster.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Poormaster")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum PotwhiskyElement: Codable, Hashable { + case integer(Int) + case potwhiskyClass(PotwhiskyClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(PotwhiskyClass.self) { + self = .potwhiskyClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(PotwhiskyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PotwhiskyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .potwhiskyClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - PotwhiskyClass +struct PotwhiskyClass: Codable, Hashable { + let arciform: JSONNull? + let cresolin: JSONNull? + let disheartener: JSONNull? + let disproportionable: JSONNull? + let euchorda: JSONNull? + let ferryway: JSONNull? + let filamentiferous: JSONNull? + let flemish: JSONNull? + let forgainst: JSONNull? + let grainering: JSONNull? + let irrevoluble: JSONNull? + let kindredship: JSONNull? + let pinguitudinous: JSONNull? + let simpletonic: JSONNull? + let singsong: JSONNull? + let submergement: JSONNull? + let supraoesophagal: JSONNull? + let thrashel: JSONNull? + let tyremesis: JSONNull? + let yoruba: JSONNull? + + enum CodingKeys: String, CodingKey { + case arciform = "arciform" + case cresolin = "cresolin" + case disheartener = "disheartener" + case disproportionable = "disproportionable" + case euchorda = "Euchorda" + case ferryway = "ferryway" + case filamentiferous = "filamentiferous" + case flemish = "flemish" + case forgainst = "forgainst" + case grainering = "grainering" + case irrevoluble = "irrevoluble" + case kindredship = "kindredship" + case pinguitudinous = "pinguitudinous" + case simpletonic = "simpletonic" + case singsong = "singsong" + case submergement = "submergement" + case supraoesophagal = "supraoesophagal" + case thrashel = "thrashel" + case tyremesis = "tyremesis" + case yoruba = "Yoruba" + } +} + +// MARK: PotwhiskyClass convenience initializers and mutators + +extension PotwhiskyClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(PotwhiskyClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + arciform: JSONNull?? = nil, + cresolin: JSONNull?? = nil, + disheartener: JSONNull?? = nil, + disproportionable: JSONNull?? = nil, + euchorda: JSONNull?? = nil, + ferryway: JSONNull?? = nil, + filamentiferous: JSONNull?? = nil, + flemish: JSONNull?? = nil, + forgainst: JSONNull?? = nil, + grainering: JSONNull?? = nil, + irrevoluble: JSONNull?? = nil, + kindredship: JSONNull?? = nil, + pinguitudinous: JSONNull?? = nil, + simpletonic: JSONNull?? = nil, + singsong: JSONNull?? = nil, + submergement: JSONNull?? = nil, + supraoesophagal: JSONNull?? = nil, + thrashel: JSONNull?? = nil, + tyremesis: JSONNull?? = nil, + yoruba: JSONNull?? = nil + ) -> PotwhiskyClass { + return PotwhiskyClass( + arciform: arciform ?? self.arciform, + cresolin: cresolin ?? self.cresolin, + disheartener: disheartener ?? self.disheartener, + disproportionable: disproportionable ?? self.disproportionable, + euchorda: euchorda ?? self.euchorda, + ferryway: ferryway ?? self.ferryway, + filamentiferous: filamentiferous ?? self.filamentiferous, + flemish: flemish ?? self.flemish, + forgainst: forgainst ?? self.forgainst, + grainering: grainering ?? self.grainering, + irrevoluble: irrevoluble ?? self.irrevoluble, + kindredship: kindredship ?? self.kindredship, + pinguitudinous: pinguitudinous ?? self.pinguitudinous, + simpletonic: simpletonic ?? self.simpletonic, + singsong: singsong ?? self.singsong, + submergement: submergement ?? self.submergement, + supraoesophagal: supraoesophagal ?? self.supraoesophagal, + thrashel: thrashel ?? self.thrashel, + tyremesis: tyremesis ?? self.tyremesis, + yoruba: yoruba ?? self.yoruba + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Practicalizer: Codable, Hashable { + case monaziteClass(MonaziteClass) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Practicalizer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Practicalizer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .monaziteClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum PrefreshmanElement: Codable, Hashable { + case nullArray([JSONNull?]) + case prefreshmanClass(PrefreshmanClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(PrefreshmanClass.self) { + self = .prefreshmanClass(x) + return + } + throw DecodingError.typeMismatch(PrefreshmanElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PrefreshmanElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .prefreshmanClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - PrefreshmanClass +struct PrefreshmanClass: Codable, Hashable { + let azorubine: JSONNull? + let choroiditis: JSONNull? + let coagulatory: JSONNull? + let cyclorama: JSONNull? + let dolphus: JSONNull? + let duckhearted: JSONNull? + let ficus: JSONNull? + let gemaric: JSONNull? + let jugation: JSONNull? + let myoliposis: JSONNull? + let nonnomination: JSONNull? + let palay: JSONNull? + let pentactinal: JSONNull? + let phaet: JSONNull? + let piquant: JSONNull? + let registration: JSONNull? + let remancipation: JSONNull? + let scutatiform: JSONNull? + let theodolite: JSONNull? + let underward: JSONNull? + + enum CodingKeys: String, CodingKey { + case azorubine = "azorubine" + case choroiditis = "choroiditis" + case coagulatory = "coagulatory" + case cyclorama = "cyclorama" + case dolphus = "Dolphus" + case duckhearted = "duckhearted" + case ficus = "Ficus" + case gemaric = "Gemaric" + case jugation = "jugation" + case myoliposis = "myoliposis" + case nonnomination = "nonnomination" + case palay = "palay" + case pentactinal = "pentactinal" + case phaet = "Phaet" + case piquant = "piquant" + case registration = "registration" + case remancipation = "remancipation" + case scutatiform = "scutatiform" + case theodolite = "theodolite" + case underward = "underward" + } +} + +// MARK: PrefreshmanClass convenience initializers and mutators + +extension PrefreshmanClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(PrefreshmanClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + azorubine: JSONNull?? = nil, + choroiditis: JSONNull?? = nil, + coagulatory: JSONNull?? = nil, + cyclorama: JSONNull?? = nil, + dolphus: JSONNull?? = nil, + duckhearted: JSONNull?? = nil, + ficus: JSONNull?? = nil, + gemaric: JSONNull?? = nil, + jugation: JSONNull?? = nil, + myoliposis: JSONNull?? = nil, + nonnomination: JSONNull?? = nil, + palay: JSONNull?? = nil, + pentactinal: JSONNull?? = nil, + phaet: JSONNull?? = nil, + piquant: JSONNull?? = nil, + registration: JSONNull?? = nil, + remancipation: JSONNull?? = nil, + scutatiform: JSONNull?? = nil, + theodolite: JSONNull?? = nil, + underward: JSONNull?? = nil + ) -> PrefreshmanClass { + return PrefreshmanClass( + azorubine: azorubine ?? self.azorubine, + choroiditis: choroiditis ?? self.choroiditis, + coagulatory: coagulatory ?? self.coagulatory, + cyclorama: cyclorama ?? self.cyclorama, + dolphus: dolphus ?? self.dolphus, + duckhearted: duckhearted ?? self.duckhearted, + ficus: ficus ?? self.ficus, + gemaric: gemaric ?? self.gemaric, + jugation: jugation ?? self.jugation, + myoliposis: myoliposis ?? self.myoliposis, + nonnomination: nonnomination ?? self.nonnomination, + palay: palay ?? self.palay, + pentactinal: pentactinal ?? self.pentactinal, + phaet: phaet ?? self.phaet, + piquant: piquant ?? self.piquant, + registration: registration ?? self.registration, + remancipation: remancipation ?? self.remancipation, + scutatiform: scutatiform ?? self.scutatiform, + theodolite: theodolite ?? self.theodolite, + underward: underward ?? self.underward + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Prehensility: Codable, Hashable { + case bool(Bool) + case monaziteClass(MonaziteClass) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Prehensility.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Prehensility")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Prevoidance: Codable, Hashable { + case integer(Int) + case integerArray([Int]) + case monaziteClass(MonaziteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Prevoidance.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Prevoidance")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + } + } +} + +enum Protext: Codable, Hashable { + case bool(Bool) + case integerArray([Int]) + case monaziteClass(MonaziteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(MonaziteClass.self) { + self = .monaziteClass(x) + return + } + throw DecodingError.typeMismatch(Protext.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Protext")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .monaziteClass(let x): + try container.encode(x) + } + } +} + +// MARK: - Helper functions for creating encoders and decoders + +func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder +} + +func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// MARK: - Encode/decode helpers + +class JSONNull: Codable, Hashable { + + public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool { + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(0) + } + + public init() {} + + public required init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if !container.decodeNil() { + throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull")) + } + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + try container.encodeNil() + } +} diff --git a/head/swift/test/inputs/json/priority/combinations4.json/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift b/head/swift/test/inputs/json/priority/combinations4.json/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift new file mode 100644 index 0000000..7509976 --- /dev/null +++ b/head/swift/test/inputs/json/priority/combinations4.json/final-classes-true__struct-or-class-class--d3c62ec7414d/quicktype.swift @@ -0,0 +1,4096 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +import Foundation + +// MARK: - TopLevel +final class TopLevel: Codable { + let protrusive: [Protrusive] + let pulpitism: [PulpitismElement] + let pyodermia: [PyodermiaElement] + let quebrachine: [QuebrachineElement] + let querier: [Querier] + let rebarbative: [Rebarbative] + let reimagine: [Reimagine] + let ressaut: Ressaut + let retrocervical: [Retrocervical] + let revert: [Revert] + let rewrite: [RewriteElement] + let saccoderm: [Saccoderm] + let santir: [SantirElement] + let saprophilous: [Saprophilous] + let saxten: [SaxtenElement] + let scatty: [Scatty?] + let scoffer: [Scoffer] + let scrampum: [Scrampum] + let semantic: Double + let serpentinic: [Serpentinic] + let shadowable: [Shadowable] + let sistering: [SisteringElement] + let staghunting: [Staghunting] + let stagmometer: [Stagmometer] + let stimulability: [Stimulability] + let strangleable: [Strangleable] + let strenuosity: [StrenuosityElement] + let tabaxir: [Tabaxir] + let talpiform: [Talpiform] + let thwack: [Thwack] + let to: [Double?] + let tortricine: [Tortricine] + let truantcy: [TruantcyElement] + let turgesce: [String] + let unbeginning: [Unbeginning] + let underdunged: [Double] + let undesirability: [Undesirability] + let unerasing: [Unerasing] + let unguentarium: [Unguentarium] + let unimpeachably: [UnimpeachablyElement] + let unmortgaged: [Unmortgaged] + let unobstructed: [Unobstructed] + let unreceptivity: [Unreceptivity] + let unsatisfactoriness: [Unsatisfactoriness] + let unsecurity: [Int] + let unstressed: [UnstressedElement] + let untasked: [Untasked] + let unvarying: [Unvarying] + let vehemently: [Vehemently] + let warriorship: [String: Bool] + let whitepot: [Whitepot] + let wrothy: [WrothyElement] + + enum CodingKeys: String, CodingKey { + case protrusive = "protrusive" + case pulpitism = "pulpitism" + case pyodermia = "pyodermia" + case quebrachine = "quebrachine" + case querier = "querier" + case rebarbative = "rebarbative" + case reimagine = "reimagine" + case ressaut = "ressaut" + case retrocervical = "retrocervical" + case revert = "revert" + case rewrite = "rewrite" + case saccoderm = "saccoderm" + case santir = "santir" + case saprophilous = "saprophilous" + case saxten = "saxten" + case scatty = "scatty" + case scoffer = "scoffer" + case scrampum = "scrampum" + case semantic = "semantic" + case serpentinic = "serpentinic" + case shadowable = "shadowable" + case sistering = "sistering" + case staghunting = "staghunting" + case stagmometer = "stagmometer" + case stimulability = "stimulability" + case strangleable = "strangleable" + case strenuosity = "strenuosity" + case tabaxir = "tabaxir" + case talpiform = "talpiform" + case thwack = "thwack" + case to = "to" + case tortricine = "tortricine" + case truantcy = "truantcy" + case turgesce = "turgesce" + case unbeginning = "unbeginning" + case underdunged = "underdunged" + case undesirability = "undesirability" + case unerasing = "unerasing" + case unguentarium = "unguentarium" + case unimpeachably = "unimpeachably" + case unmortgaged = "unmortgaged" + case unobstructed = "unobstructed" + case unreceptivity = "unreceptivity" + case unsatisfactoriness = "unsatisfactoriness" + case unsecurity = "unsecurity" + case unstressed = "unstressed" + case untasked = "untasked" + case unvarying = "unvarying" + case vehemently = "vehemently" + case warriorship = "warriorship" + case whitepot = "whitepot" + case wrothy = "wrothy" + } + + init(protrusive: [Protrusive], pulpitism: [PulpitismElement], pyodermia: [PyodermiaElement], quebrachine: [QuebrachineElement], querier: [Querier], rebarbative: [Rebarbative], reimagine: [Reimagine], ressaut: Ressaut, retrocervical: [Retrocervical], revert: [Revert], rewrite: [RewriteElement], saccoderm: [Saccoderm], santir: [SantirElement], saprophilous: [Saprophilous], saxten: [SaxtenElement], scatty: [Scatty?], scoffer: [Scoffer], scrampum: [Scrampum], semantic: Double, serpentinic: [Serpentinic], shadowable: [Shadowable], sistering: [SisteringElement], staghunting: [Staghunting], stagmometer: [Stagmometer], stimulability: [Stimulability], strangleable: [Strangleable], strenuosity: [StrenuosityElement], tabaxir: [Tabaxir], talpiform: [Talpiform], thwack: [Thwack], to: [Double?], tortricine: [Tortricine], truantcy: [TruantcyElement], turgesce: [String], unbeginning: [Unbeginning], underdunged: [Double], undesirability: [Undesirability], unerasing: [Unerasing], unguentarium: [Unguentarium], unimpeachably: [UnimpeachablyElement], unmortgaged: [Unmortgaged], unobstructed: [Unobstructed], unreceptivity: [Unreceptivity], unsatisfactoriness: [Unsatisfactoriness], unsecurity: [Int], unstressed: [UnstressedElement], untasked: [Untasked], unvarying: [Unvarying], vehemently: [Vehemently], warriorship: [String: Bool], whitepot: [Whitepot], wrothy: [WrothyElement]) { + self.protrusive = protrusive + self.pulpitism = pulpitism + self.pyodermia = pyodermia + self.quebrachine = quebrachine + self.querier = querier + self.rebarbative = rebarbative + self.reimagine = reimagine + self.ressaut = ressaut + self.retrocervical = retrocervical + self.revert = revert + self.rewrite = rewrite + self.saccoderm = saccoderm + self.santir = santir + self.saprophilous = saprophilous + self.saxten = saxten + self.scatty = scatty + self.scoffer = scoffer + self.scrampum = scrampum + self.semantic = semantic + self.serpentinic = serpentinic + self.shadowable = shadowable + self.sistering = sistering + self.staghunting = staghunting + self.stagmometer = stagmometer + self.stimulability = stimulability + self.strangleable = strangleable + self.strenuosity = strenuosity + self.tabaxir = tabaxir + self.talpiform = talpiform + self.thwack = thwack + self.to = to + self.tortricine = tortricine + self.truantcy = truantcy + self.turgesce = turgesce + self.unbeginning = unbeginning + self.underdunged = underdunged + self.undesirability = undesirability + self.unerasing = unerasing + self.unguentarium = unguentarium + self.unimpeachably = unimpeachably + self.unmortgaged = unmortgaged + self.unobstructed = unobstructed + self.unreceptivity = unreceptivity + self.unsatisfactoriness = unsatisfactoriness + self.unsecurity = unsecurity + self.unstressed = unstressed + self.untasked = untasked + self.unvarying = unvarying + self.vehemently = vehemently + self.warriorship = warriorship + self.whitepot = whitepot + self.wrothy = wrothy + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(TopLevel.self, from: data) + self.init(protrusive: me.protrusive, pulpitism: me.pulpitism, pyodermia: me.pyodermia, quebrachine: me.quebrachine, querier: me.querier, rebarbative: me.rebarbative, reimagine: me.reimagine, ressaut: me.ressaut, retrocervical: me.retrocervical, revert: me.revert, rewrite: me.rewrite, saccoderm: me.saccoderm, santir: me.santir, saprophilous: me.saprophilous, saxten: me.saxten, scatty: me.scatty, scoffer: me.scoffer, scrampum: me.scrampum, semantic: me.semantic, serpentinic: me.serpentinic, shadowable: me.shadowable, sistering: me.sistering, staghunting: me.staghunting, stagmometer: me.stagmometer, stimulability: me.stimulability, strangleable: me.strangleable, strenuosity: me.strenuosity, tabaxir: me.tabaxir, talpiform: me.talpiform, thwack: me.thwack, to: me.to, tortricine: me.tortricine, truantcy: me.truantcy, turgesce: me.turgesce, unbeginning: me.unbeginning, underdunged: me.underdunged, undesirability: me.undesirability, unerasing: me.unerasing, unguentarium: me.unguentarium, unimpeachably: me.unimpeachably, unmortgaged: me.unmortgaged, unobstructed: me.unobstructed, unreceptivity: me.unreceptivity, unsatisfactoriness: me.unsatisfactoriness, unsecurity: me.unsecurity, unstressed: me.unstressed, untasked: me.untasked, unvarying: me.unvarying, vehemently: me.vehemently, warriorship: me.warriorship, whitepot: me.whitepot, wrothy: me.wrothy) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + protrusive: [Protrusive]? = nil, + pulpitism: [PulpitismElement]? = nil, + pyodermia: [PyodermiaElement]? = nil, + quebrachine: [QuebrachineElement]? = nil, + querier: [Querier]? = nil, + rebarbative: [Rebarbative]? = nil, + reimagine: [Reimagine]? = nil, + ressaut: Ressaut? = nil, + retrocervical: [Retrocervical]? = nil, + revert: [Revert]? = nil, + rewrite: [RewriteElement]? = nil, + saccoderm: [Saccoderm]? = nil, + santir: [SantirElement]? = nil, + saprophilous: [Saprophilous]? = nil, + saxten: [SaxtenElement]? = nil, + scatty: [Scatty?]? = nil, + scoffer: [Scoffer]? = nil, + scrampum: [Scrampum]? = nil, + semantic: Double? = nil, + serpentinic: [Serpentinic]? = nil, + shadowable: [Shadowable]? = nil, + sistering: [SisteringElement]? = nil, + staghunting: [Staghunting]? = nil, + stagmometer: [Stagmometer]? = nil, + stimulability: [Stimulability]? = nil, + strangleable: [Strangleable]? = nil, + strenuosity: [StrenuosityElement]? = nil, + tabaxir: [Tabaxir]? = nil, + talpiform: [Talpiform]? = nil, + thwack: [Thwack]? = nil, + to: [Double?]? = nil, + tortricine: [Tortricine]? = nil, + truantcy: [TruantcyElement]? = nil, + turgesce: [String]? = nil, + unbeginning: [Unbeginning]? = nil, + underdunged: [Double]? = nil, + undesirability: [Undesirability]? = nil, + unerasing: [Unerasing]? = nil, + unguentarium: [Unguentarium]? = nil, + unimpeachably: [UnimpeachablyElement]? = nil, + unmortgaged: [Unmortgaged]? = nil, + unobstructed: [Unobstructed]? = nil, + unreceptivity: [Unreceptivity]? = nil, + unsatisfactoriness: [Unsatisfactoriness]? = nil, + unsecurity: [Int]? = nil, + unstressed: [UnstressedElement]? = nil, + untasked: [Untasked]? = nil, + unvarying: [Unvarying]? = nil, + vehemently: [Vehemently]? = nil, + warriorship: [String: Bool]? = nil, + whitepot: [Whitepot]? = nil, + wrothy: [WrothyElement]? = nil + ) -> TopLevel { + return TopLevel( + protrusive: protrusive ?? self.protrusive, + pulpitism: pulpitism ?? self.pulpitism, + pyodermia: pyodermia ?? self.pyodermia, + quebrachine: quebrachine ?? self.quebrachine, + querier: querier ?? self.querier, + rebarbative: rebarbative ?? self.rebarbative, + reimagine: reimagine ?? self.reimagine, + ressaut: ressaut ?? self.ressaut, + retrocervical: retrocervical ?? self.retrocervical, + revert: revert ?? self.revert, + rewrite: rewrite ?? self.rewrite, + saccoderm: saccoderm ?? self.saccoderm, + santir: santir ?? self.santir, + saprophilous: saprophilous ?? self.saprophilous, + saxten: saxten ?? self.saxten, + scatty: scatty ?? self.scatty, + scoffer: scoffer ?? self.scoffer, + scrampum: scrampum ?? self.scrampum, + semantic: semantic ?? self.semantic, + serpentinic: serpentinic ?? self.serpentinic, + shadowable: shadowable ?? self.shadowable, + sistering: sistering ?? self.sistering, + staghunting: staghunting ?? self.staghunting, + stagmometer: stagmometer ?? self.stagmometer, + stimulability: stimulability ?? self.stimulability, + strangleable: strangleable ?? self.strangleable, + strenuosity: strenuosity ?? self.strenuosity, + tabaxir: tabaxir ?? self.tabaxir, + talpiform: talpiform ?? self.talpiform, + thwack: thwack ?? self.thwack, + to: to ?? self.to, + tortricine: tortricine ?? self.tortricine, + truantcy: truantcy ?? self.truantcy, + turgesce: turgesce ?? self.turgesce, + unbeginning: unbeginning ?? self.unbeginning, + underdunged: underdunged ?? self.underdunged, + undesirability: undesirability ?? self.undesirability, + unerasing: unerasing ?? self.unerasing, + unguentarium: unguentarium ?? self.unguentarium, + unimpeachably: unimpeachably ?? self.unimpeachably, + unmortgaged: unmortgaged ?? self.unmortgaged, + unobstructed: unobstructed ?? self.unobstructed, + unreceptivity: unreceptivity ?? self.unreceptivity, + unsatisfactoriness: unsatisfactoriness ?? self.unsatisfactoriness, + unsecurity: unsecurity ?? self.unsecurity, + unstressed: unstressed ?? self.unstressed, + untasked: untasked ?? self.untasked, + unvarying: unvarying ?? self.unvarying, + vehemently: vehemently ?? self.vehemently, + warriorship: warriorship ?? self.warriorship, + whitepot: whitepot ?? self.whitepot, + wrothy: wrothy ?? self.wrothy + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Protrusive: Codable { + case double(Double) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Protrusive.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Protrusive")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +enum PulpitismElement: Codable { + case double(Double) + case integerArray([Int]) + case pulpitismClass(PulpitismClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(PulpitismClass.self) { + self = .pulpitismClass(x) + return + } + throw DecodingError.typeMismatch(PulpitismElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PulpitismElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .pulpitismClass(let x): + try container.encode(x) + } + } +} + +// MARK: - PulpitismClass +final class PulpitismClass: Codable { + let abnet: JSONNull? + let buckhorn: JSONNull? + let calciform: JSONNull? + let chelophore: JSONNull? + let cogitation: JSONNull? + let decreeable: JSONNull? + let despicable: JSONNull? + let isodiazo: JSONNull? + let jadedly: JSONNull? + let leptochlorite: JSONNull? + let nursling: JSONNull? + let palamedean: JSONNull? + let photoheliograph: JSONNull? + let pipewood: JSONNull? + let roberd: JSONNull? + let statable: JSONNull? + let superassume: JSONNull? + let syllabe: JSONNull? + let toughhead: JSONNull? + let underburn: JSONNull? + + enum CodingKeys: String, CodingKey { + case abnet = "abnet" + case buckhorn = "buckhorn" + case calciform = "calciform" + case chelophore = "chelophore" + case cogitation = "cogitation" + case decreeable = "decreeable" + case despicable = "despicable" + case isodiazo = "isodiazo" + case jadedly = "jadedly" + case leptochlorite = "leptochlorite" + case nursling = "nursling" + case palamedean = "palamedean" + case photoheliograph = "photoheliograph" + case pipewood = "pipewood" + case roberd = "roberd" + case statable = "statable" + case superassume = "superassume" + case syllabe = "syllabe" + case toughhead = "toughhead" + case underburn = "underburn" + } + + init(abnet: JSONNull?, buckhorn: JSONNull?, calciform: JSONNull?, chelophore: JSONNull?, cogitation: JSONNull?, decreeable: JSONNull?, despicable: JSONNull?, isodiazo: JSONNull?, jadedly: JSONNull?, leptochlorite: JSONNull?, nursling: JSONNull?, palamedean: JSONNull?, photoheliograph: JSONNull?, pipewood: JSONNull?, roberd: JSONNull?, statable: JSONNull?, superassume: JSONNull?, syllabe: JSONNull?, toughhead: JSONNull?, underburn: JSONNull?) { + self.abnet = abnet + self.buckhorn = buckhorn + self.calciform = calciform + self.chelophore = chelophore + self.cogitation = cogitation + self.decreeable = decreeable + self.despicable = despicable + self.isodiazo = isodiazo + self.jadedly = jadedly + self.leptochlorite = leptochlorite + self.nursling = nursling + self.palamedean = palamedean + self.photoheliograph = photoheliograph + self.pipewood = pipewood + self.roberd = roberd + self.statable = statable + self.superassume = superassume + self.syllabe = syllabe + self.toughhead = toughhead + self.underburn = underburn + } +} + +// MARK: PulpitismClass convenience initializers and mutators + +extension PulpitismClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(PulpitismClass.self, from: data) + self.init(abnet: me.abnet, buckhorn: me.buckhorn, calciform: me.calciform, chelophore: me.chelophore, cogitation: me.cogitation, decreeable: me.decreeable, despicable: me.despicable, isodiazo: me.isodiazo, jadedly: me.jadedly, leptochlorite: me.leptochlorite, nursling: me.nursling, palamedean: me.palamedean, photoheliograph: me.photoheliograph, pipewood: me.pipewood, roberd: me.roberd, statable: me.statable, superassume: me.superassume, syllabe: me.syllabe, toughhead: me.toughhead, underburn: me.underburn) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + abnet: JSONNull?? = nil, + buckhorn: JSONNull?? = nil, + calciform: JSONNull?? = nil, + chelophore: JSONNull?? = nil, + cogitation: JSONNull?? = nil, + decreeable: JSONNull?? = nil, + despicable: JSONNull?? = nil, + isodiazo: JSONNull?? = nil, + jadedly: JSONNull?? = nil, + leptochlorite: JSONNull?? = nil, + nursling: JSONNull?? = nil, + palamedean: JSONNull?? = nil, + photoheliograph: JSONNull?? = nil, + pipewood: JSONNull?? = nil, + roberd: JSONNull?? = nil, + statable: JSONNull?? = nil, + superassume: JSONNull?? = nil, + syllabe: JSONNull?? = nil, + toughhead: JSONNull?? = nil, + underburn: JSONNull?? = nil + ) -> PulpitismClass { + return PulpitismClass( + abnet: abnet ?? self.abnet, + buckhorn: buckhorn ?? self.buckhorn, + calciform: calciform ?? self.calciform, + chelophore: chelophore ?? self.chelophore, + cogitation: cogitation ?? self.cogitation, + decreeable: decreeable ?? self.decreeable, + despicable: despicable ?? self.despicable, + isodiazo: isodiazo ?? self.isodiazo, + jadedly: jadedly ?? self.jadedly, + leptochlorite: leptochlorite ?? self.leptochlorite, + nursling: nursling ?? self.nursling, + palamedean: palamedean ?? self.palamedean, + photoheliograph: photoheliograph ?? self.photoheliograph, + pipewood: pipewood ?? self.pipewood, + roberd: roberd ?? self.roberd, + statable: statable ?? self.statable, + superassume: superassume ?? self.superassume, + syllabe: syllabe ?? self.syllabe, + toughhead: toughhead ?? self.toughhead, + underburn: underburn ?? self.underburn + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum PyodermiaElement: Codable { + case integer(Int) + case pyodermiaClass(PyodermiaClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(PyodermiaClass.self) { + self = .pyodermiaClass(x) + return + } + throw DecodingError.typeMismatch(PyodermiaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PyodermiaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .pyodermiaClass(let x): + try container.encode(x) + } + } +} + +// MARK: - PyodermiaClass +final class PyodermiaClass: Codable { + let aphoristically: JSONNull? + let apophyllous: JSONNull? + let cognize: JSONNull? + let dermonosology: JSONNull? + let gyppo: JSONNull? + let ither: JSONNull? + let juglandaceous: JSONNull? + let litho: JSONNull? + let macropterous: JSONNull? + let photographer: JSONNull? + let romancing: JSONNull? + let rumness: JSONNull? + let somniloquist: JSONNull? + let stressfully: JSONNull? + let tactically: JSONNull? + let tracheophony: JSONNull? + let unappositely: JSONNull? + let unclothedly: JSONNull? + let unimplied: JSONNull? + let unsyncopated: JSONNull? + + enum CodingKeys: String, CodingKey { + case aphoristically = "aphoristically" + case apophyllous = "apophyllous" + case cognize = "cognize" + case dermonosology = "dermonosology" + case gyppo = "Gyppo" + case ither = "ither" + case juglandaceous = "juglandaceous" + case litho = "litho" + case macropterous = "macropterous" + case photographer = "photographer" + case romancing = "romancing" + case rumness = "rumness" + case somniloquist = "somniloquist" + case stressfully = "stressfully" + case tactically = "tactically" + case tracheophony = "tracheophony" + case unappositely = "unappositely" + case unclothedly = "unclothedly" + case unimplied = "unimplied" + case unsyncopated = "unsyncopated" + } + + init(aphoristically: JSONNull?, apophyllous: JSONNull?, cognize: JSONNull?, dermonosology: JSONNull?, gyppo: JSONNull?, ither: JSONNull?, juglandaceous: JSONNull?, litho: JSONNull?, macropterous: JSONNull?, photographer: JSONNull?, romancing: JSONNull?, rumness: JSONNull?, somniloquist: JSONNull?, stressfully: JSONNull?, tactically: JSONNull?, tracheophony: JSONNull?, unappositely: JSONNull?, unclothedly: JSONNull?, unimplied: JSONNull?, unsyncopated: JSONNull?) { + self.aphoristically = aphoristically + self.apophyllous = apophyllous + self.cognize = cognize + self.dermonosology = dermonosology + self.gyppo = gyppo + self.ither = ither + self.juglandaceous = juglandaceous + self.litho = litho + self.macropterous = macropterous + self.photographer = photographer + self.romancing = romancing + self.rumness = rumness + self.somniloquist = somniloquist + self.stressfully = stressfully + self.tactically = tactically + self.tracheophony = tracheophony + self.unappositely = unappositely + self.unclothedly = unclothedly + self.unimplied = unimplied + self.unsyncopated = unsyncopated + } +} + +// MARK: PyodermiaClass convenience initializers and mutators + +extension PyodermiaClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(PyodermiaClass.self, from: data) + self.init(aphoristically: me.aphoristically, apophyllous: me.apophyllous, cognize: me.cognize, dermonosology: me.dermonosology, gyppo: me.gyppo, ither: me.ither, juglandaceous: me.juglandaceous, litho: me.litho, macropterous: me.macropterous, photographer: me.photographer, romancing: me.romancing, rumness: me.rumness, somniloquist: me.somniloquist, stressfully: me.stressfully, tactically: me.tactically, tracheophony: me.tracheophony, unappositely: me.unappositely, unclothedly: me.unclothedly, unimplied: me.unimplied, unsyncopated: me.unsyncopated) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + aphoristically: JSONNull?? = nil, + apophyllous: JSONNull?? = nil, + cognize: JSONNull?? = nil, + dermonosology: JSONNull?? = nil, + gyppo: JSONNull?? = nil, + ither: JSONNull?? = nil, + juglandaceous: JSONNull?? = nil, + litho: JSONNull?? = nil, + macropterous: JSONNull?? = nil, + photographer: JSONNull?? = nil, + romancing: JSONNull?? = nil, + rumness: JSONNull?? = nil, + somniloquist: JSONNull?? = nil, + stressfully: JSONNull?? = nil, + tactically: JSONNull?? = nil, + tracheophony: JSONNull?? = nil, + unappositely: JSONNull?? = nil, + unclothedly: JSONNull?? = nil, + unimplied: JSONNull?? = nil, + unsyncopated: JSONNull?? = nil + ) -> PyodermiaClass { + return PyodermiaClass( + aphoristically: aphoristically ?? self.aphoristically, + apophyllous: apophyllous ?? self.apophyllous, + cognize: cognize ?? self.cognize, + dermonosology: dermonosology ?? self.dermonosology, + gyppo: gyppo ?? self.gyppo, + ither: ither ?? self.ither, + juglandaceous: juglandaceous ?? self.juglandaceous, + litho: litho ?? self.litho, + macropterous: macropterous ?? self.macropterous, + photographer: photographer ?? self.photographer, + romancing: romancing ?? self.romancing, + rumness: rumness ?? self.rumness, + somniloquist: somniloquist ?? self.somniloquist, + stressfully: stressfully ?? self.stressfully, + tactically: tactically ?? self.tactically, + tracheophony: tracheophony ?? self.tracheophony, + unappositely: unappositely ?? self.unappositely, + unclothedly: unclothedly ?? self.unclothedly, + unimplied: unimplied ?? self.unimplied, + unsyncopated: unsyncopated ?? self.unsyncopated + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum QuebrachineElement: Codable { + case bool(Bool) + case quebrachineClass(QuebrachineClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(QuebrachineElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for QuebrachineElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// MARK: - QuebrachineClass +final class QuebrachineClass: Codable { + let catharticalness: Double + let chirotherium: Int + let disdiapason: String + let homocerc: Bool + let nonbookish: JSONNull? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case homocerc = "homocerc" + case nonbookish = "nonbookish" + } + + init(catharticalness: Double, chirotherium: Int, disdiapason: String, homocerc: Bool, nonbookish: JSONNull?) { + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.homocerc = homocerc + self.nonbookish = nonbookish + } +} + +// MARK: QuebrachineClass convenience initializers and mutators + +extension QuebrachineClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(QuebrachineClass.self, from: data) + self.init(catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, homocerc: me.homocerc, nonbookish: me.nonbookish) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double? = nil, + chirotherium: Int? = nil, + disdiapason: String? = nil, + homocerc: Bool? = nil, + nonbookish: JSONNull?? = nil + ) -> QuebrachineClass { + return QuebrachineClass( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + homocerc: homocerc ?? self.homocerc, + nonbookish: nonbookish ?? self.nonbookish + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Querier: Codable { + case bool(Bool) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Querier.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Querier")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Rebarbative: Codable { + case bool(Bool) + case double(Double) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Rebarbative.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Rebarbative")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +// MARK: - Reimagine +final class Reimagine: Codable { + let adducible: JSONNull? + let anabolin: JSONNull? + let brainy: JSONNull? + let catharticalness: Double? + let chirotherium: Int? + let chrysamine: JSONNull? + let disdiapason: String? + let fluxweed: JSONNull? + let glaucine: JSONNull? + let grobianism: JSONNull? + let hermo: JSONNull? + let hieroglyphist: JSONNull? + let homocerc: Bool? + let icteroid: JSONNull? + let immortal: JSONNull? + let impetulant: JSONNull? + let irrigate: JSONNull? + let myxedema: JSONNull? + let nonbookish: JSONNull? + let onyx: JSONNull? + let repasser: JSONNull? + let septomarginal: JSONNull? + let subdie: JSONNull? + let tibiometatarsal: JSONNull? + let waltzlike: JSONNull? + + enum CodingKeys: String, CodingKey { + case adducible = "adducible" + case anabolin = "anabolin" + case brainy = "brainy" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case chrysamine = "chrysamine" + case disdiapason = "disdiapason" + case fluxweed = "fluxweed" + case glaucine = "glaucine" + case grobianism = "grobianism" + case hermo = "Hermo" + case hieroglyphist = "hieroglyphist" + case homocerc = "homocerc" + case icteroid = "icteroid" + case immortal = "immortal" + case impetulant = "impetulant" + case irrigate = "irrigate" + case myxedema = "myxedema" + case nonbookish = "nonbookish" + case onyx = "onyx" + case repasser = "repasser" + case septomarginal = "septomarginal" + case subdie = "subdie" + case tibiometatarsal = "tibiometatarsal" + case waltzlike = "waltzlike" + } + + init(adducible: JSONNull?, anabolin: JSONNull?, brainy: JSONNull?, catharticalness: Double?, chirotherium: Int?, chrysamine: JSONNull?, disdiapason: String?, fluxweed: JSONNull?, glaucine: JSONNull?, grobianism: JSONNull?, hermo: JSONNull?, hieroglyphist: JSONNull?, homocerc: Bool?, icteroid: JSONNull?, immortal: JSONNull?, impetulant: JSONNull?, irrigate: JSONNull?, myxedema: JSONNull?, nonbookish: JSONNull?, onyx: JSONNull?, repasser: JSONNull?, septomarginal: JSONNull?, subdie: JSONNull?, tibiometatarsal: JSONNull?, waltzlike: JSONNull?) { + self.adducible = adducible + self.anabolin = anabolin + self.brainy = brainy + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.chrysamine = chrysamine + self.disdiapason = disdiapason + self.fluxweed = fluxweed + self.glaucine = glaucine + self.grobianism = grobianism + self.hermo = hermo + self.hieroglyphist = hieroglyphist + self.homocerc = homocerc + self.icteroid = icteroid + self.immortal = immortal + self.impetulant = impetulant + self.irrigate = irrigate + self.myxedema = myxedema + self.nonbookish = nonbookish + self.onyx = onyx + self.repasser = repasser + self.septomarginal = septomarginal + self.subdie = subdie + self.tibiometatarsal = tibiometatarsal + self.waltzlike = waltzlike + } +} + +// MARK: Reimagine convenience initializers and mutators + +extension Reimagine { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Reimagine.self, from: data) + self.init(adducible: me.adducible, anabolin: me.anabolin, brainy: me.brainy, catharticalness: me.catharticalness, chirotherium: me.chirotherium, chrysamine: me.chrysamine, disdiapason: me.disdiapason, fluxweed: me.fluxweed, glaucine: me.glaucine, grobianism: me.grobianism, hermo: me.hermo, hieroglyphist: me.hieroglyphist, homocerc: me.homocerc, icteroid: me.icteroid, immortal: me.immortal, impetulant: me.impetulant, irrigate: me.irrigate, myxedema: me.myxedema, nonbookish: me.nonbookish, onyx: me.onyx, repasser: me.repasser, septomarginal: me.septomarginal, subdie: me.subdie, tibiometatarsal: me.tibiometatarsal, waltzlike: me.waltzlike) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + adducible: JSONNull?? = nil, + anabolin: JSONNull?? = nil, + brainy: JSONNull?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + chrysamine: JSONNull?? = nil, + disdiapason: String?? = nil, + fluxweed: JSONNull?? = nil, + glaucine: JSONNull?? = nil, + grobianism: JSONNull?? = nil, + hermo: JSONNull?? = nil, + hieroglyphist: JSONNull?? = nil, + homocerc: Bool?? = nil, + icteroid: JSONNull?? = nil, + immortal: JSONNull?? = nil, + impetulant: JSONNull?? = nil, + irrigate: JSONNull?? = nil, + myxedema: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + onyx: JSONNull?? = nil, + repasser: JSONNull?? = nil, + septomarginal: JSONNull?? = nil, + subdie: JSONNull?? = nil, + tibiometatarsal: JSONNull?? = nil, + waltzlike: JSONNull?? = nil + ) -> Reimagine { + return Reimagine( + adducible: adducible ?? self.adducible, + anabolin: anabolin ?? self.anabolin, + brainy: brainy ?? self.brainy, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + chrysamine: chrysamine ?? self.chrysamine, + disdiapason: disdiapason ?? self.disdiapason, + fluxweed: fluxweed ?? self.fluxweed, + glaucine: glaucine ?? self.glaucine, + grobianism: grobianism ?? self.grobianism, + hermo: hermo ?? self.hermo, + hieroglyphist: hieroglyphist ?? self.hieroglyphist, + homocerc: homocerc ?? self.homocerc, + icteroid: icteroid ?? self.icteroid, + immortal: immortal ?? self.immortal, + impetulant: impetulant ?? self.impetulant, + irrigate: irrigate ?? self.irrigate, + myxedema: myxedema ?? self.myxedema, + nonbookish: nonbookish ?? self.nonbookish, + onyx: onyx ?? self.onyx, + repasser: repasser ?? self.repasser, + septomarginal: septomarginal ?? self.septomarginal, + subdie: subdie ?? self.subdie, + tibiometatarsal: tibiometatarsal ?? self.tibiometatarsal, + waltzlike: waltzlike ?? self.waltzlike + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Ressaut +final class Ressaut: Codable { + let apperceptive: String + let cuttoo: String + let douser: String + let drinkproof: String + let forementioned: String + let freesia: String + let genevieve: String + let hyperdiabolical: String + let hypocone: String + let irreverentially: String + let jumart: String + let mimosaceae: String + let mollicrush: String + let nedder: String + let retinasphalt: String + let sough: String + let steading: String + let theopaschitism: String + let undurableness: String + let unmingleable: String + + enum CodingKeys: String, CodingKey { + case apperceptive = "apperceptive" + case cuttoo = "cuttoo" + case douser = "douser" + case drinkproof = "drinkproof" + case forementioned = "forementioned" + case freesia = "Freesia" + case genevieve = "Genevieve" + case hyperdiabolical = "hyperdiabolical" + case hypocone = "hypocone" + case irreverentially = "irreverentially" + case jumart = "jumart" + case mimosaceae = "Mimosaceae" + case mollicrush = "mollicrush" + case nedder = "nedder" + case retinasphalt = "retinasphalt" + case sough = "sough" + case steading = "steading" + case theopaschitism = "Theopaschitism" + case undurableness = "undurableness" + case unmingleable = "unmingleable" + } + + init(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: String) { + self.apperceptive = apperceptive + self.cuttoo = cuttoo + self.douser = douser + self.drinkproof = drinkproof + self.forementioned = forementioned + self.freesia = freesia + self.genevieve = genevieve + self.hyperdiabolical = hyperdiabolical + self.hypocone = hypocone + self.irreverentially = irreverentially + self.jumart = jumart + self.mimosaceae = mimosaceae + self.mollicrush = mollicrush + self.nedder = nedder + self.retinasphalt = retinasphalt + self.sough = sough + self.steading = steading + self.theopaschitism = theopaschitism + self.undurableness = undurableness + self.unmingleable = unmingleable + } +} + +// MARK: Ressaut convenience initializers and mutators + +extension Ressaut { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Ressaut.self, from: data) + self.init(apperceptive: me.apperceptive, cuttoo: me.cuttoo, douser: me.douser, drinkproof: me.drinkproof, forementioned: me.forementioned, freesia: me.freesia, genevieve: me.genevieve, hyperdiabolical: me.hyperdiabolical, hypocone: me.hypocone, irreverentially: me.irreverentially, jumart: me.jumart, mimosaceae: me.mimosaceae, mollicrush: me.mollicrush, nedder: me.nedder, retinasphalt: me.retinasphalt, sough: me.sough, steading: me.steading, theopaschitism: me.theopaschitism, undurableness: me.undurableness, unmingleable: me.unmingleable) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + apperceptive: String? = nil, + cuttoo: String? = nil, + douser: String? = nil, + drinkproof: String? = nil, + forementioned: String? = nil, + freesia: String? = nil, + genevieve: String? = nil, + hyperdiabolical: String? = nil, + hypocone: String? = nil, + irreverentially: String? = nil, + jumart: String? = nil, + mimosaceae: String? = nil, + mollicrush: String? = nil, + nedder: String? = nil, + retinasphalt: String? = nil, + sough: String? = nil, + steading: String? = nil, + theopaschitism: String? = nil, + undurableness: String? = nil, + unmingleable: String? = nil + ) -> Ressaut { + return Ressaut( + apperceptive: apperceptive ?? self.apperceptive, + cuttoo: cuttoo ?? self.cuttoo, + douser: douser ?? self.douser, + drinkproof: drinkproof ?? self.drinkproof, + forementioned: forementioned ?? self.forementioned, + freesia: freesia ?? self.freesia, + genevieve: genevieve ?? self.genevieve, + hyperdiabolical: hyperdiabolical ?? self.hyperdiabolical, + hypocone: hypocone ?? self.hypocone, + irreverentially: irreverentially ?? self.irreverentially, + jumart: jumart ?? self.jumart, + mimosaceae: mimosaceae ?? self.mimosaceae, + mollicrush: mollicrush ?? self.mollicrush, + nedder: nedder ?? self.nedder, + retinasphalt: retinasphalt ?? self.retinasphalt, + sough: sough ?? self.sough, + steading: steading ?? self.steading, + theopaschitism: theopaschitism ?? self.theopaschitism, + undurableness: undurableness ?? self.undurableness, + unmingleable: unmingleable ?? self.unmingleable + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Retrocervical: Codable { + case integer(Int) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + throw DecodingError.typeMismatch(Retrocervical.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Retrocervical")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +enum Revert: Codable { + case bool(Bool) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Revert.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Revert")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum RewriteElement: Codable { + case double(Double) + case nullArray([JSONNull?]) + case rewriteClass(RewriteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(RewriteClass.self) { + self = .rewriteClass(x) + return + } + throw DecodingError.typeMismatch(RewriteElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for RewriteElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .rewriteClass(let x): + try container.encode(x) + } + } +} + +// MARK: - RewriteClass +final class RewriteClass: Codable { + let accountancy: JSONNull? + let cacotrophic: JSONNull? + let contest: JSONNull? + let couthily: JSONNull? + let falculate: JSONNull? + let foreseize: JSONNull? + let hyades: JSONNull? + let lemnad: JSONNull? + let monotheistically: JSONNull? + let nonflying: JSONNull? + let ptenoglossa: JSONNull? + let repatch: JSONNull? + let rodman: JSONNull? + let strung: JSONNull? + let titmal: JSONNull? + let twalpennyworth: JSONNull? + let unblamable: JSONNull? + let vertical: JSONNull? + let whiggification: JSONNull? + let yardman: JSONNull? + + enum CodingKeys: String, CodingKey { + case accountancy = "accountancy" + case cacotrophic = "cacotrophic" + case contest = "contest" + case couthily = "couthily" + case falculate = "falculate" + case foreseize = "foreseize" + case hyades = "Hyades" + case lemnad = "lemnad" + case monotheistically = "monotheistically" + case nonflying = "nonflying" + case ptenoglossa = "Ptenoglossa" + case repatch = "repatch" + case rodman = "rodman" + case strung = "strung" + case titmal = "titmal" + case twalpennyworth = "twalpennyworth" + case unblamable = "unblamable" + case vertical = "vertical" + case whiggification = "Whiggification" + case yardman = "yardman" + } + + init(accountancy: JSONNull?, cacotrophic: JSONNull?, contest: JSONNull?, couthily: JSONNull?, falculate: JSONNull?, foreseize: JSONNull?, hyades: JSONNull?, lemnad: JSONNull?, monotheistically: JSONNull?, nonflying: JSONNull?, ptenoglossa: JSONNull?, repatch: JSONNull?, rodman: JSONNull?, strung: JSONNull?, titmal: JSONNull?, twalpennyworth: JSONNull?, unblamable: JSONNull?, vertical: JSONNull?, whiggification: JSONNull?, yardman: JSONNull?) { + self.accountancy = accountancy + self.cacotrophic = cacotrophic + self.contest = contest + self.couthily = couthily + self.falculate = falculate + self.foreseize = foreseize + self.hyades = hyades + self.lemnad = lemnad + self.monotheistically = monotheistically + self.nonflying = nonflying + self.ptenoglossa = ptenoglossa + self.repatch = repatch + self.rodman = rodman + self.strung = strung + self.titmal = titmal + self.twalpennyworth = twalpennyworth + self.unblamable = unblamable + self.vertical = vertical + self.whiggification = whiggification + self.yardman = yardman + } +} + +// MARK: RewriteClass convenience initializers and mutators + +extension RewriteClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(RewriteClass.self, from: data) + self.init(accountancy: me.accountancy, cacotrophic: me.cacotrophic, contest: me.contest, couthily: me.couthily, falculate: me.falculate, foreseize: me.foreseize, hyades: me.hyades, lemnad: me.lemnad, monotheistically: me.monotheistically, nonflying: me.nonflying, ptenoglossa: me.ptenoglossa, repatch: me.repatch, rodman: me.rodman, strung: me.strung, titmal: me.titmal, twalpennyworth: me.twalpennyworth, unblamable: me.unblamable, vertical: me.vertical, whiggification: me.whiggification, yardman: me.yardman) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + accountancy: JSONNull?? = nil, + cacotrophic: JSONNull?? = nil, + contest: JSONNull?? = nil, + couthily: JSONNull?? = nil, + falculate: JSONNull?? = nil, + foreseize: JSONNull?? = nil, + hyades: JSONNull?? = nil, + lemnad: JSONNull?? = nil, + monotheistically: JSONNull?? = nil, + nonflying: JSONNull?? = nil, + ptenoglossa: JSONNull?? = nil, + repatch: JSONNull?? = nil, + rodman: JSONNull?? = nil, + strung: JSONNull?? = nil, + titmal: JSONNull?? = nil, + twalpennyworth: JSONNull?? = nil, + unblamable: JSONNull?? = nil, + vertical: JSONNull?? = nil, + whiggification: JSONNull?? = nil, + yardman: JSONNull?? = nil + ) -> RewriteClass { + return RewriteClass( + accountancy: accountancy ?? self.accountancy, + cacotrophic: cacotrophic ?? self.cacotrophic, + contest: contest ?? self.contest, + couthily: couthily ?? self.couthily, + falculate: falculate ?? self.falculate, + foreseize: foreseize ?? self.foreseize, + hyades: hyades ?? self.hyades, + lemnad: lemnad ?? self.lemnad, + monotheistically: monotheistically ?? self.monotheistically, + nonflying: nonflying ?? self.nonflying, + ptenoglossa: ptenoglossa ?? self.ptenoglossa, + repatch: repatch ?? self.repatch, + rodman: rodman ?? self.rodman, + strung: strung ?? self.strung, + titmal: titmal ?? self.titmal, + twalpennyworth: twalpennyworth ?? self.twalpennyworth, + unblamable: unblamable ?? self.unblamable, + vertical: vertical ?? self.vertical, + whiggification: whiggification ?? self.whiggification, + yardman: yardman ?? self.yardman + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Saccoderm: Codable { + case integerArray([Int]) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Saccoderm.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Saccoderm")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum SantirElement: Codable { + case double(Double) + case santirClass(SantirClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(SantirClass.self) { + self = .santirClass(x) + return + } + throw DecodingError.typeMismatch(SantirElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for SantirElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .santirClass(let x): + try container.encode(x) + } + } +} + +// MARK: - SantirClass +final class SantirClass: Codable { + let admiredly: JSONNull? + let demicaponier: JSONNull? + let epitympanic: JSONNull? + let investitor: JSONNull? + let lupiform: JSONNull? + let monoflagellate: JSONNull? + let paleoethnic: JSONNull? + let prediscountable: JSONNull? + let rhetoricals: JSONNull? + let roomth: JSONNull? + let saccharose: JSONNull? + let septonasal: JSONNull? + let serpenticide: JSONNull? + let setarious: JSONNull? + let spaework: JSONNull? + let stylite: JSONNull? + let suessiones: JSONNull? + let timelily: JSONNull? + let unprofaned: JSONNull? + let vorticular: JSONNull? + + enum CodingKeys: String, CodingKey { + case admiredly = "admiredly" + case demicaponier = "demicaponier" + case epitympanic = "epitympanic" + case investitor = "investitor" + case lupiform = "lupiform" + case monoflagellate = "monoflagellate" + case paleoethnic = "paleoethnic" + case prediscountable = "prediscountable" + case rhetoricals = "rhetoricals" + case roomth = "roomth" + case saccharose = "saccharose" + case septonasal = "septonasal" + case serpenticide = "serpenticide" + case setarious = "setarious" + case spaework = "spaework" + case stylite = "stylite" + case suessiones = "Suessiones" + case timelily = "timelily" + case unprofaned = "unprofaned" + case vorticular = "vorticular" + } + + init(admiredly: JSONNull?, demicaponier: JSONNull?, epitympanic: JSONNull?, investitor: JSONNull?, lupiform: JSONNull?, monoflagellate: JSONNull?, paleoethnic: JSONNull?, prediscountable: JSONNull?, rhetoricals: JSONNull?, roomth: JSONNull?, saccharose: JSONNull?, septonasal: JSONNull?, serpenticide: JSONNull?, setarious: JSONNull?, spaework: JSONNull?, stylite: JSONNull?, suessiones: JSONNull?, timelily: JSONNull?, unprofaned: JSONNull?, vorticular: JSONNull?) { + self.admiredly = admiredly + self.demicaponier = demicaponier + self.epitympanic = epitympanic + self.investitor = investitor + self.lupiform = lupiform + self.monoflagellate = monoflagellate + self.paleoethnic = paleoethnic + self.prediscountable = prediscountable + self.rhetoricals = rhetoricals + self.roomth = roomth + self.saccharose = saccharose + self.septonasal = septonasal + self.serpenticide = serpenticide + self.setarious = setarious + self.spaework = spaework + self.stylite = stylite + self.suessiones = suessiones + self.timelily = timelily + self.unprofaned = unprofaned + self.vorticular = vorticular + } +} + +// MARK: SantirClass convenience initializers and mutators + +extension SantirClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(SantirClass.self, from: data) + self.init(admiredly: me.admiredly, demicaponier: me.demicaponier, epitympanic: me.epitympanic, investitor: me.investitor, lupiform: me.lupiform, monoflagellate: me.monoflagellate, paleoethnic: me.paleoethnic, prediscountable: me.prediscountable, rhetoricals: me.rhetoricals, roomth: me.roomth, saccharose: me.saccharose, septonasal: me.septonasal, serpenticide: me.serpenticide, setarious: me.setarious, spaework: me.spaework, stylite: me.stylite, suessiones: me.suessiones, timelily: me.timelily, unprofaned: me.unprofaned, vorticular: me.vorticular) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + admiredly: JSONNull?? = nil, + demicaponier: JSONNull?? = nil, + epitympanic: JSONNull?? = nil, + investitor: JSONNull?? = nil, + lupiform: JSONNull?? = nil, + monoflagellate: JSONNull?? = nil, + paleoethnic: JSONNull?? = nil, + prediscountable: JSONNull?? = nil, + rhetoricals: JSONNull?? = nil, + roomth: JSONNull?? = nil, + saccharose: JSONNull?? = nil, + septonasal: JSONNull?? = nil, + serpenticide: JSONNull?? = nil, + setarious: JSONNull?? = nil, + spaework: JSONNull?? = nil, + stylite: JSONNull?? = nil, + suessiones: JSONNull?? = nil, + timelily: JSONNull?? = nil, + unprofaned: JSONNull?? = nil, + vorticular: JSONNull?? = nil + ) -> SantirClass { + return SantirClass( + admiredly: admiredly ?? self.admiredly, + demicaponier: demicaponier ?? self.demicaponier, + epitympanic: epitympanic ?? self.epitympanic, + investitor: investitor ?? self.investitor, + lupiform: lupiform ?? self.lupiform, + monoflagellate: monoflagellate ?? self.monoflagellate, + paleoethnic: paleoethnic ?? self.paleoethnic, + prediscountable: prediscountable ?? self.prediscountable, + rhetoricals: rhetoricals ?? self.rhetoricals, + roomth: roomth ?? self.roomth, + saccharose: saccharose ?? self.saccharose, + septonasal: septonasal ?? self.septonasal, + serpenticide: serpenticide ?? self.serpenticide, + setarious: setarious ?? self.setarious, + spaework: spaework ?? self.spaework, + stylite: stylite ?? self.stylite, + suessiones: suessiones ?? self.suessiones, + timelily: timelily ?? self.timelily, + unprofaned: unprofaned ?? self.unprofaned, + vorticular: vorticular ?? self.vorticular + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Saprophilous: Codable { + case integerMap([String: Int]) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Saprophilous.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Saprophilous")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum SaxtenElement: Codable { + case saxtenClass(SaxtenClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(SaxtenClass.self) { + self = .saxtenClass(x) + return + } + throw DecodingError.typeMismatch(SaxtenElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for SaxtenElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .saxtenClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// MARK: - SaxtenClass +final class SaxtenClass: Codable { + let algarrobilla: JSONNull? + let bowgrace: JSONNull? + let catharticalness: Double? + let centaurid: JSONNull? + let chirotherium: Int? + let disdiapason: String? + let flix: JSONNull? + let germanely: JSONNull? + let homocerc: Bool? + let inhume: JSONNull? + let lepidote: JSONNull? + let megalochirous: JSONNull? + let ninepenny: JSONNull? + let nonbookish: JSONNull? + let nondeist: JSONNull? + let nymphaeaceous: JSONNull? + let parietofrontal: JSONNull? + let sancyite: JSONNull? + let subjectivist: JSONNull? + let tibiad: JSONNull? + let transonic: JSONNull? + let tripetalous: JSONNull? + let trunchman: JSONNull? + let urger: JSONNull? + let withdrawnness: JSONNull? + + enum CodingKeys: String, CodingKey { + case algarrobilla = "algarrobilla" + case bowgrace = "bowgrace" + case catharticalness = "catharticalness" + case centaurid = "Centaurid" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case flix = "flix" + case germanely = "germanely" + case homocerc = "homocerc" + case inhume = "inhume" + case lepidote = "lepidote" + case megalochirous = "megalochirous" + case ninepenny = "ninepenny" + case nonbookish = "nonbookish" + case nondeist = "nondeist" + case nymphaeaceous = "nymphaeaceous" + case parietofrontal = "parietofrontal" + case sancyite = "sancyite" + case subjectivist = "subjectivist" + case tibiad = "tibiad" + case transonic = "transonic" + case tripetalous = "tripetalous" + case trunchman = "trunchman" + case urger = "urger" + case withdrawnness = "withdrawnness" + } + + init(algarrobilla: JSONNull?, bowgrace: JSONNull?, catharticalness: Double?, centaurid: JSONNull?, chirotherium: Int?, disdiapason: String?, flix: JSONNull?, germanely: JSONNull?, homocerc: Bool?, inhume: JSONNull?, lepidote: JSONNull?, megalochirous: JSONNull?, ninepenny: JSONNull?, nonbookish: JSONNull?, nondeist: JSONNull?, nymphaeaceous: JSONNull?, parietofrontal: JSONNull?, sancyite: JSONNull?, subjectivist: JSONNull?, tibiad: JSONNull?, transonic: JSONNull?, tripetalous: JSONNull?, trunchman: JSONNull?, urger: JSONNull?, withdrawnness: JSONNull?) { + self.algarrobilla = algarrobilla + self.bowgrace = bowgrace + self.catharticalness = catharticalness + self.centaurid = centaurid + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.flix = flix + self.germanely = germanely + self.homocerc = homocerc + self.inhume = inhume + self.lepidote = lepidote + self.megalochirous = megalochirous + self.ninepenny = ninepenny + self.nonbookish = nonbookish + self.nondeist = nondeist + self.nymphaeaceous = nymphaeaceous + self.parietofrontal = parietofrontal + self.sancyite = sancyite + self.subjectivist = subjectivist + self.tibiad = tibiad + self.transonic = transonic + self.tripetalous = tripetalous + self.trunchman = trunchman + self.urger = urger + self.withdrawnness = withdrawnness + } +} + +// MARK: SaxtenClass convenience initializers and mutators + +extension SaxtenClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(SaxtenClass.self, from: data) + self.init(algarrobilla: me.algarrobilla, bowgrace: me.bowgrace, catharticalness: me.catharticalness, centaurid: me.centaurid, chirotherium: me.chirotherium, disdiapason: me.disdiapason, flix: me.flix, germanely: me.germanely, homocerc: me.homocerc, inhume: me.inhume, lepidote: me.lepidote, megalochirous: me.megalochirous, ninepenny: me.ninepenny, nonbookish: me.nonbookish, nondeist: me.nondeist, nymphaeaceous: me.nymphaeaceous, parietofrontal: me.parietofrontal, sancyite: me.sancyite, subjectivist: me.subjectivist, tibiad: me.tibiad, transonic: me.transonic, tripetalous: me.tripetalous, trunchman: me.trunchman, urger: me.urger, withdrawnness: me.withdrawnness) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + algarrobilla: JSONNull?? = nil, + bowgrace: JSONNull?? = nil, + catharticalness: Double?? = nil, + centaurid: JSONNull?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + flix: JSONNull?? = nil, + germanely: JSONNull?? = nil, + homocerc: Bool?? = nil, + inhume: JSONNull?? = nil, + lepidote: JSONNull?? = nil, + megalochirous: JSONNull?? = nil, + ninepenny: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + nondeist: JSONNull?? = nil, + nymphaeaceous: JSONNull?? = nil, + parietofrontal: JSONNull?? = nil, + sancyite: JSONNull?? = nil, + subjectivist: JSONNull?? = nil, + tibiad: JSONNull?? = nil, + transonic: JSONNull?? = nil, + tripetalous: JSONNull?? = nil, + trunchman: JSONNull?? = nil, + urger: JSONNull?? = nil, + withdrawnness: JSONNull?? = nil + ) -> SaxtenClass { + return SaxtenClass( + algarrobilla: algarrobilla ?? self.algarrobilla, + bowgrace: bowgrace ?? self.bowgrace, + catharticalness: catharticalness ?? self.catharticalness, + centaurid: centaurid ?? self.centaurid, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + flix: flix ?? self.flix, + germanely: germanely ?? self.germanely, + homocerc: homocerc ?? self.homocerc, + inhume: inhume ?? self.inhume, + lepidote: lepidote ?? self.lepidote, + megalochirous: megalochirous ?? self.megalochirous, + ninepenny: ninepenny ?? self.ninepenny, + nonbookish: nonbookish ?? self.nonbookish, + nondeist: nondeist ?? self.nondeist, + nymphaeaceous: nymphaeaceous ?? self.nymphaeaceous, + parietofrontal: parietofrontal ?? self.parietofrontal, + sancyite: sancyite ?? self.sancyite, + subjectivist: subjectivist ?? self.subjectivist, + tibiad: tibiad ?? self.tibiad, + transonic: transonic ?? self.transonic, + tripetalous: tripetalous ?? self.tripetalous, + trunchman: trunchman ?? self.trunchman, + urger: urger ?? self.urger, + withdrawnness: withdrawnness ?? self.withdrawnness + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Scatty +final class Scatty: Codable { + let aeriferous: JSONNull? + let antical: JSONNull? + let antighostism: JSONNull? + let arcanum: JSONNull? + let autotrophy: JSONNull? + let baronial: JSONNull? + let caffeine: JSONNull? + let gorgoniacean: JSONNull? + let heroical: JSONNull? + let hydropical: JSONNull? + let mechanology: JSONNull? + let musicopoetic: JSONNull? + let officiality: JSONNull? + let oftentimes: JSONNull? + let ophthalmotonometer: JSONNull? + let reflectively: JSONNull? + let springer: JSONNull? + let tabasco: JSONNull? + let teleianthous: JSONNull? + let uncombated: JSONNull? + + enum CodingKeys: String, CodingKey { + case aeriferous = "aeriferous" + case antical = "antical" + case antighostism = "antighostism" + case arcanum = "arcanum" + case autotrophy = "autotrophy" + case baronial = "baronial" + case caffeine = "caffeine" + case gorgoniacean = "gorgoniacean" + case heroical = "heroical" + case hydropical = "hydropical" + case mechanology = "mechanology" + case musicopoetic = "musicopoetic" + case officiality = "officiality" + case oftentimes = "oftentimes" + case ophthalmotonometer = "ophthalmotonometer" + case reflectively = "reflectively" + case springer = "springer" + case tabasco = "Tabasco" + case teleianthous = "teleianthous" + case uncombated = "uncombated" + } + + init(aeriferous: JSONNull?, antical: JSONNull?, antighostism: JSONNull?, arcanum: JSONNull?, autotrophy: JSONNull?, baronial: JSONNull?, caffeine: JSONNull?, gorgoniacean: JSONNull?, heroical: JSONNull?, hydropical: JSONNull?, mechanology: JSONNull?, musicopoetic: JSONNull?, officiality: JSONNull?, oftentimes: JSONNull?, ophthalmotonometer: JSONNull?, reflectively: JSONNull?, springer: JSONNull?, tabasco: JSONNull?, teleianthous: JSONNull?, uncombated: JSONNull?) { + self.aeriferous = aeriferous + self.antical = antical + self.antighostism = antighostism + self.arcanum = arcanum + self.autotrophy = autotrophy + self.baronial = baronial + self.caffeine = caffeine + self.gorgoniacean = gorgoniacean + self.heroical = heroical + self.hydropical = hydropical + self.mechanology = mechanology + self.musicopoetic = musicopoetic + self.officiality = officiality + self.oftentimes = oftentimes + self.ophthalmotonometer = ophthalmotonometer + self.reflectively = reflectively + self.springer = springer + self.tabasco = tabasco + self.teleianthous = teleianthous + self.uncombated = uncombated + } +} + +// MARK: Scatty convenience initializers and mutators + +extension Scatty { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Scatty.self, from: data) + self.init(aeriferous: me.aeriferous, antical: me.antical, antighostism: me.antighostism, arcanum: me.arcanum, autotrophy: me.autotrophy, baronial: me.baronial, caffeine: me.caffeine, gorgoniacean: me.gorgoniacean, heroical: me.heroical, hydropical: me.hydropical, mechanology: me.mechanology, musicopoetic: me.musicopoetic, officiality: me.officiality, oftentimes: me.oftentimes, ophthalmotonometer: me.ophthalmotonometer, reflectively: me.reflectively, springer: me.springer, tabasco: me.tabasco, teleianthous: me.teleianthous, uncombated: me.uncombated) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + aeriferous: JSONNull?? = nil, + antical: JSONNull?? = nil, + antighostism: JSONNull?? = nil, + arcanum: JSONNull?? = nil, + autotrophy: JSONNull?? = nil, + baronial: JSONNull?? = nil, + caffeine: JSONNull?? = nil, + gorgoniacean: JSONNull?? = nil, + heroical: JSONNull?? = nil, + hydropical: JSONNull?? = nil, + mechanology: JSONNull?? = nil, + musicopoetic: JSONNull?? = nil, + officiality: JSONNull?? = nil, + oftentimes: JSONNull?? = nil, + ophthalmotonometer: JSONNull?? = nil, + reflectively: JSONNull?? = nil, + springer: JSONNull?? = nil, + tabasco: JSONNull?? = nil, + teleianthous: JSONNull?? = nil, + uncombated: JSONNull?? = nil + ) -> Scatty { + return Scatty( + aeriferous: aeriferous ?? self.aeriferous, + antical: antical ?? self.antical, + antighostism: antighostism ?? self.antighostism, + arcanum: arcanum ?? self.arcanum, + autotrophy: autotrophy ?? self.autotrophy, + baronial: baronial ?? self.baronial, + caffeine: caffeine ?? self.caffeine, + gorgoniacean: gorgoniacean ?? self.gorgoniacean, + heroical: heroical ?? self.heroical, + hydropical: hydropical ?? self.hydropical, + mechanology: mechanology ?? self.mechanology, + musicopoetic: musicopoetic ?? self.musicopoetic, + officiality: officiality ?? self.officiality, + oftentimes: oftentimes ?? self.oftentimes, + ophthalmotonometer: ophthalmotonometer ?? self.ophthalmotonometer, + reflectively: reflectively ?? self.reflectively, + springer: springer ?? self.springer, + tabasco: tabasco ?? self.tabasco, + teleianthous: teleianthous ?? self.teleianthous, + uncombated: uncombated ?? self.uncombated + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Scoffer: Codable { + case integerMap([String: Int]) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Scoffer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Scoffer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Scrampum: Codable { + case bool(Bool) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Scrampum.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Scrampum")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Serpentinic: Codable { + case double(Double) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Serpentinic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Serpentinic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +enum Shadowable: Codable { + case bool(Bool) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + throw DecodingError.typeMismatch(Shadowable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Shadowable")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +enum SisteringElement: Codable { + case integer(Int) + case nullArray([JSONNull?]) + case sisteringClass(SisteringClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(SisteringClass.self) { + self = .sisteringClass(x) + return + } + throw DecodingError.typeMismatch(SisteringElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for SisteringElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .sisteringClass(let x): + try container.encode(x) + } + } +} + +// MARK: - SisteringClass +final class SisteringClass: Codable { + let amphicarpic: JSONNull? + let chianti: JSONNull? + let frigorific: JSONNull? + let haplomi: JSONNull? + let hyperkinesis: JSONNull? + let laudable: JSONNull? + let madwoman: JSONNull? + let maimedly: JSONNull? + let micropterygidae: JSONNull? + let microrhabdus: JSONNull? + let nondense: JSONNull? + let phlebemphraxis: JSONNull? + let redsear: JSONNull? + let schismatical: JSONNull? + let tartryl: JSONNull? + let unabhorred: JSONNull? + let undeliberateness: JSONNull? + let unmixable: JSONNull? + let untruckling: JSONNull? + let vineal: JSONNull? + + enum CodingKeys: String, CodingKey { + case amphicarpic = "amphicarpic" + case chianti = "Chianti" + case frigorific = "frigorific" + case haplomi = "Haplomi" + case hyperkinesis = "hyperkinesis" + case laudable = "laudable" + case madwoman = "madwoman" + case maimedly = "maimedly" + case micropterygidae = "Micropterygidae" + case microrhabdus = "microrhabdus" + case nondense = "nondense" + case phlebemphraxis = "phlebemphraxis" + case redsear = "redsear" + case schismatical = "schismatical" + case tartryl = "tartryl" + case unabhorred = "unabhorred" + case undeliberateness = "undeliberateness" + case unmixable = "unmixable" + case untruckling = "untruckling" + case vineal = "vineal" + } + + init(amphicarpic: JSONNull?, chianti: JSONNull?, frigorific: JSONNull?, haplomi: JSONNull?, hyperkinesis: JSONNull?, laudable: JSONNull?, madwoman: JSONNull?, maimedly: JSONNull?, micropterygidae: JSONNull?, microrhabdus: JSONNull?, nondense: JSONNull?, phlebemphraxis: JSONNull?, redsear: JSONNull?, schismatical: JSONNull?, tartryl: JSONNull?, unabhorred: JSONNull?, undeliberateness: JSONNull?, unmixable: JSONNull?, untruckling: JSONNull?, vineal: JSONNull?) { + self.amphicarpic = amphicarpic + self.chianti = chianti + self.frigorific = frigorific + self.haplomi = haplomi + self.hyperkinesis = hyperkinesis + self.laudable = laudable + self.madwoman = madwoman + self.maimedly = maimedly + self.micropterygidae = micropterygidae + self.microrhabdus = microrhabdus + self.nondense = nondense + self.phlebemphraxis = phlebemphraxis + self.redsear = redsear + self.schismatical = schismatical + self.tartryl = tartryl + self.unabhorred = unabhorred + self.undeliberateness = undeliberateness + self.unmixable = unmixable + self.untruckling = untruckling + self.vineal = vineal + } +} + +// MARK: SisteringClass convenience initializers and mutators + +extension SisteringClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(SisteringClass.self, from: data) + self.init(amphicarpic: me.amphicarpic, chianti: me.chianti, frigorific: me.frigorific, haplomi: me.haplomi, hyperkinesis: me.hyperkinesis, laudable: me.laudable, madwoman: me.madwoman, maimedly: me.maimedly, micropterygidae: me.micropterygidae, microrhabdus: me.microrhabdus, nondense: me.nondense, phlebemphraxis: me.phlebemphraxis, redsear: me.redsear, schismatical: me.schismatical, tartryl: me.tartryl, unabhorred: me.unabhorred, undeliberateness: me.undeliberateness, unmixable: me.unmixable, untruckling: me.untruckling, vineal: me.vineal) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + amphicarpic: JSONNull?? = nil, + chianti: JSONNull?? = nil, + frigorific: JSONNull?? = nil, + haplomi: JSONNull?? = nil, + hyperkinesis: JSONNull?? = nil, + laudable: JSONNull?? = nil, + madwoman: JSONNull?? = nil, + maimedly: JSONNull?? = nil, + micropterygidae: JSONNull?? = nil, + microrhabdus: JSONNull?? = nil, + nondense: JSONNull?? = nil, + phlebemphraxis: JSONNull?? = nil, + redsear: JSONNull?? = nil, + schismatical: JSONNull?? = nil, + tartryl: JSONNull?? = nil, + unabhorred: JSONNull?? = nil, + undeliberateness: JSONNull?? = nil, + unmixable: JSONNull?? = nil, + untruckling: JSONNull?? = nil, + vineal: JSONNull?? = nil + ) -> SisteringClass { + return SisteringClass( + amphicarpic: amphicarpic ?? self.amphicarpic, + chianti: chianti ?? self.chianti, + frigorific: frigorific ?? self.frigorific, + haplomi: haplomi ?? self.haplomi, + hyperkinesis: hyperkinesis ?? self.hyperkinesis, + laudable: laudable ?? self.laudable, + madwoman: madwoman ?? self.madwoman, + maimedly: maimedly ?? self.maimedly, + micropterygidae: micropterygidae ?? self.micropterygidae, + microrhabdus: microrhabdus ?? self.microrhabdus, + nondense: nondense ?? self.nondense, + phlebemphraxis: phlebemphraxis ?? self.phlebemphraxis, + redsear: redsear ?? self.redsear, + schismatical: schismatical ?? self.schismatical, + tartryl: tartryl ?? self.tartryl, + unabhorred: unabhorred ?? self.unabhorred, + undeliberateness: undeliberateness ?? self.undeliberateness, + unmixable: unmixable ?? self.unmixable, + untruckling: untruckling ?? self.untruckling, + vineal: vineal ?? self.vineal + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Staghunting +final class Staghunting: Codable { + let calorimetric: Int? + let canid: Int? + let catharticalness: Double? + let chirotherium: Int? + let disdiapason: String? + let ditriglyphic: Int? + let floriferousness: Int? + let gamelike: Int? + let grig: Int? + let homocerc: Bool? + let interloan: Int? + let lithotomy: Int? + let loric: Int? + let membranocoriaceous: Int? + let membranogenic: Int? + let nonbookish: JSONNull? + let overtrump: Int? + let scotino: Int? + let seasonable: Int? + let sephen: Int? + let stigmarioid: Int? + let tired: Int? + let trifid: Int? + let undefeatedly: Int? + let ungirlish: Int? + + enum CodingKeys: String, CodingKey { + case calorimetric = "calorimetric" + case canid = "canid" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case ditriglyphic = "ditriglyphic" + case floriferousness = "floriferousness" + case gamelike = "gamelike" + case grig = "grig" + case homocerc = "homocerc" + case interloan = "interloan" + case lithotomy = "lithotomy" + case loric = "loric" + case membranocoriaceous = "membranocoriaceous" + case membranogenic = "membranogenic" + case nonbookish = "nonbookish" + case overtrump = "overtrump" + case scotino = "scotino" + case seasonable = "seasonable" + case sephen = "sephen" + case stigmarioid = "stigmarioid" + case tired = "tired" + case trifid = "trifid" + case undefeatedly = "undefeatedly" + case ungirlish = "ungirlish" + } + + init(calorimetric: Int?, canid: Int?, catharticalness: Double?, chirotherium: Int?, disdiapason: String?, ditriglyphic: Int?, floriferousness: Int?, gamelike: Int?, grig: Int?, homocerc: Bool?, interloan: Int?, lithotomy: Int?, loric: Int?, membranocoriaceous: Int?, membranogenic: Int?, nonbookish: JSONNull?, overtrump: Int?, scotino: Int?, seasonable: Int?, sephen: Int?, stigmarioid: Int?, tired: Int?, trifid: Int?, undefeatedly: Int?, ungirlish: Int?) { + self.calorimetric = calorimetric + self.canid = canid + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.disdiapason = disdiapason + self.ditriglyphic = ditriglyphic + self.floriferousness = floriferousness + self.gamelike = gamelike + self.grig = grig + self.homocerc = homocerc + self.interloan = interloan + self.lithotomy = lithotomy + self.loric = loric + self.membranocoriaceous = membranocoriaceous + self.membranogenic = membranogenic + self.nonbookish = nonbookish + self.overtrump = overtrump + self.scotino = scotino + self.seasonable = seasonable + self.sephen = sephen + self.stigmarioid = stigmarioid + self.tired = tired + self.trifid = trifid + self.undefeatedly = undefeatedly + self.ungirlish = ungirlish + } +} + +// MARK: Staghunting convenience initializers and mutators + +extension Staghunting { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(Staghunting.self, from: data) + self.init(calorimetric: me.calorimetric, canid: me.canid, catharticalness: me.catharticalness, chirotherium: me.chirotherium, disdiapason: me.disdiapason, ditriglyphic: me.ditriglyphic, floriferousness: me.floriferousness, gamelike: me.gamelike, grig: me.grig, homocerc: me.homocerc, interloan: me.interloan, lithotomy: me.lithotomy, loric: me.loric, membranocoriaceous: me.membranocoriaceous, membranogenic: me.membranogenic, nonbookish: me.nonbookish, overtrump: me.overtrump, scotino: me.scotino, seasonable: me.seasonable, sephen: me.sephen, stigmarioid: me.stigmarioid, tired: me.tired, trifid: me.trifid, undefeatedly: me.undefeatedly, ungirlish: me.ungirlish) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + calorimetric: Int?? = nil, + canid: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + ditriglyphic: Int?? = nil, + floriferousness: Int?? = nil, + gamelike: Int?? = nil, + grig: Int?? = nil, + homocerc: Bool?? = nil, + interloan: Int?? = nil, + lithotomy: Int?? = nil, + loric: Int?? = nil, + membranocoriaceous: Int?? = nil, + membranogenic: Int?? = nil, + nonbookish: JSONNull?? = nil, + overtrump: Int?? = nil, + scotino: Int?? = nil, + seasonable: Int?? = nil, + sephen: Int?? = nil, + stigmarioid: Int?? = nil, + tired: Int?? = nil, + trifid: Int?? = nil, + undefeatedly: Int?? = nil, + ungirlish: Int?? = nil + ) -> Staghunting { + return Staghunting( + calorimetric: calorimetric ?? self.calorimetric, + canid: canid ?? self.canid, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + ditriglyphic: ditriglyphic ?? self.ditriglyphic, + floriferousness: floriferousness ?? self.floriferousness, + gamelike: gamelike ?? self.gamelike, + grig: grig ?? self.grig, + homocerc: homocerc ?? self.homocerc, + interloan: interloan ?? self.interloan, + lithotomy: lithotomy ?? self.lithotomy, + loric: loric ?? self.loric, + membranocoriaceous: membranocoriaceous ?? self.membranocoriaceous, + membranogenic: membranogenic ?? self.membranogenic, + nonbookish: nonbookish ?? self.nonbookish, + overtrump: overtrump ?? self.overtrump, + scotino: scotino ?? self.scotino, + seasonable: seasonable ?? self.seasonable, + sephen: sephen ?? self.sephen, + stigmarioid: stigmarioid ?? self.stigmarioid, + tired: tired ?? self.tired, + trifid: trifid ?? self.trifid, + undefeatedly: undefeatedly ?? self.undefeatedly, + ungirlish: ungirlish ?? self.ungirlish + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Stagmometer: Codable { + case string(String) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Stagmometer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Stagmometer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .string(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +enum Stimulability: Codable { + case bool(Bool) + case integer(Int) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Stimulability.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Stimulability")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Strangleable: Codable { + case double(Double) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Strangleable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Strangleable")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum StrenuosityElement: Codable { + case nullArray([JSONNull?]) + case strenuosityClass(StrenuosityClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(StrenuosityClass.self) { + self = .strenuosityClass(x) + return + } + throw DecodingError.typeMismatch(StrenuosityElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for StrenuosityElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .strenuosityClass(let x): + try container.encode(x) + } + } +} + +// MARK: - StrenuosityClass +final class StrenuosityClass: Codable { + let bliss: Int? + let buccate: Int? + let bulletproof: Int? + let catharticalness: Double? + let chirotherium: Int? + let crumblingness: Int? + let disdiapason: String? + let engagedly: Int? + let fightable: Int? + let hoariness: Int? + let homocerc: Bool? + let hypopodium: Int? + let luxurist: Int? + let mechanician: Int? + let nonbookish: JSONNull? + let onopordon: Int? + let podgily: Int? + let reformableness: Int? + let scatterbrains: Int? + let seminuria: Int? + let sodomite: Int? + let tramp: Int? + let undueness: Int? + let worthily: Int? + let yankeeist: Int? + + enum CodingKeys: String, CodingKey { + case bliss = "bliss" + case buccate = "buccate" + case bulletproof = "bulletproof" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case crumblingness = "crumblingness" + case disdiapason = "disdiapason" + case engagedly = "engagedly" + case fightable = "fightable" + case hoariness = "hoariness" + case homocerc = "homocerc" + case hypopodium = "hypopodium" + case luxurist = "luxurist" + case mechanician = "mechanician" + case nonbookish = "nonbookish" + case onopordon = "Onopordon" + case podgily = "podgily" + case reformableness = "reformableness" + case scatterbrains = "scatterbrains" + case seminuria = "seminuria" + case sodomite = "Sodomite" + case tramp = "tramp" + case undueness = "undueness" + case worthily = "worthily" + case yankeeist = "Yankeeist" + } + + init(bliss: Int?, buccate: Int?, bulletproof: Int?, catharticalness: Double?, chirotherium: Int?, crumblingness: Int?, disdiapason: String?, engagedly: Int?, fightable: Int?, hoariness: Int?, homocerc: Bool?, hypopodium: Int?, luxurist: Int?, mechanician: Int?, nonbookish: JSONNull?, onopordon: Int?, podgily: Int?, reformableness: Int?, scatterbrains: Int?, seminuria: Int?, sodomite: Int?, tramp: Int?, undueness: Int?, worthily: Int?, yankeeist: Int?) { + self.bliss = bliss + self.buccate = buccate + self.bulletproof = bulletproof + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.crumblingness = crumblingness + self.disdiapason = disdiapason + self.engagedly = engagedly + self.fightable = fightable + self.hoariness = hoariness + self.homocerc = homocerc + self.hypopodium = hypopodium + self.luxurist = luxurist + self.mechanician = mechanician + self.nonbookish = nonbookish + self.onopordon = onopordon + self.podgily = podgily + self.reformableness = reformableness + self.scatterbrains = scatterbrains + self.seminuria = seminuria + self.sodomite = sodomite + self.tramp = tramp + self.undueness = undueness + self.worthily = worthily + self.yankeeist = yankeeist + } +} + +// MARK: StrenuosityClass convenience initializers and mutators + +extension StrenuosityClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(StrenuosityClass.self, from: data) + self.init(bliss: me.bliss, buccate: me.buccate, bulletproof: me.bulletproof, catharticalness: me.catharticalness, chirotherium: me.chirotherium, crumblingness: me.crumblingness, disdiapason: me.disdiapason, engagedly: me.engagedly, fightable: me.fightable, hoariness: me.hoariness, homocerc: me.homocerc, hypopodium: me.hypopodium, luxurist: me.luxurist, mechanician: me.mechanician, nonbookish: me.nonbookish, onopordon: me.onopordon, podgily: me.podgily, reformableness: me.reformableness, scatterbrains: me.scatterbrains, seminuria: me.seminuria, sodomite: me.sodomite, tramp: me.tramp, undueness: me.undueness, worthily: me.worthily, yankeeist: me.yankeeist) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + bliss: Int?? = nil, + buccate: Int?? = nil, + bulletproof: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + crumblingness: Int?? = nil, + disdiapason: String?? = nil, + engagedly: Int?? = nil, + fightable: Int?? = nil, + hoariness: Int?? = nil, + homocerc: Bool?? = nil, + hypopodium: Int?? = nil, + luxurist: Int?? = nil, + mechanician: Int?? = nil, + nonbookish: JSONNull?? = nil, + onopordon: Int?? = nil, + podgily: Int?? = nil, + reformableness: Int?? = nil, + scatterbrains: Int?? = nil, + seminuria: Int?? = nil, + sodomite: Int?? = nil, + tramp: Int?? = nil, + undueness: Int?? = nil, + worthily: Int?? = nil, + yankeeist: Int?? = nil + ) -> StrenuosityClass { + return StrenuosityClass( + bliss: bliss ?? self.bliss, + buccate: buccate ?? self.buccate, + bulletproof: bulletproof ?? self.bulletproof, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + crumblingness: crumblingness ?? self.crumblingness, + disdiapason: disdiapason ?? self.disdiapason, + engagedly: engagedly ?? self.engagedly, + fightable: fightable ?? self.fightable, + hoariness: hoariness ?? self.hoariness, + homocerc: homocerc ?? self.homocerc, + hypopodium: hypopodium ?? self.hypopodium, + luxurist: luxurist ?? self.luxurist, + mechanician: mechanician ?? self.mechanician, + nonbookish: nonbookish ?? self.nonbookish, + onopordon: onopordon ?? self.onopordon, + podgily: podgily ?? self.podgily, + reformableness: reformableness ?? self.reformableness, + scatterbrains: scatterbrains ?? self.scatterbrains, + seminuria: seminuria ?? self.seminuria, + sodomite: sodomite ?? self.sodomite, + tramp: tramp ?? self.tramp, + undueness: undueness ?? self.undueness, + worthily: worthily ?? self.worthily, + yankeeist: yankeeist ?? self.yankeeist + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Tabaxir: Codable { + case bool(Bool) + case double(Double) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Tabaxir.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Tabaxir")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + } + } +} + +enum Talpiform: Codable { + case double(Double) + case quebrachineClass(QuebrachineClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Talpiform.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Talpiform")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Thwack: Codable { + case bool(Bool) + case double(Double) + case quebrachineClass(QuebrachineClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + throw DecodingError.typeMismatch(Thwack.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Thwack")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + } + } +} + +enum Tortricine: Codable { + case quebrachineClass(QuebrachineClass) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode(QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + throw DecodingError.typeMismatch(Tortricine.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Tortricine")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .quebrachineClass(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +enum TruantcyElement: Codable { + case bool(Bool) + case truantcyClass(TruantcyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(TruantcyClass.self) { + self = .truantcyClass(x) + return + } + throw DecodingError.typeMismatch(TruantcyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for TruantcyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .truantcyClass(let x): + try container.encode(x) + } + } +} + +// MARK: - TruantcyClass +final class TruantcyClass: Codable { + let alfiona: JSONNull? + let ascaridiasis: JSONNull? + let bungey: JSONNull? + let catharticalness: Double? + let ceroxyle: JSONNull? + let chirotherium: Int? + let chorology: JSONNull? + let disdiapason: String? + let enmarble: JSONNull? + let epeira: JSONNull? + let eurylaimi: JSONNull? + let germination: JSONNull? + let hallelujah: JSONNull? + let homocerc: Bool? + let lev: JSONNull? + let mouthing: JSONNull? + let nonbookish: JSONNull? + let philliloo: JSONNull? + let planetal: JSONNull? + let poney: JSONNull? + let punctualist: JSONNull? + let returnlessly: JSONNull? + let skelder: JSONNull? + let windwaywardly: JSONNull? + let yuman: JSONNull? + + enum CodingKeys: String, CodingKey { + case alfiona = "alfiona" + case ascaridiasis = "ascaridiasis" + case bungey = "bungey" + case catharticalness = "catharticalness" + case ceroxyle = "ceroxyle" + case chirotherium = "Chirotherium" + case chorology = "chorology" + case disdiapason = "disdiapason" + case enmarble = "enmarble" + case epeira = "Epeira" + case eurylaimi = "Eurylaimi" + case germination = "germination" + case hallelujah = "hallelujah" + case homocerc = "homocerc" + case lev = "lev" + case mouthing = "mouthing" + case nonbookish = "nonbookish" + case philliloo = "philliloo" + case planetal = "planetal" + case poney = "poney" + case punctualist = "punctualist" + case returnlessly = "returnlessly" + case skelder = "skelder" + case windwaywardly = "windwaywardly" + case yuman = "Yuman" + } + + init(alfiona: JSONNull?, ascaridiasis: JSONNull?, bungey: JSONNull?, catharticalness: Double?, ceroxyle: JSONNull?, chirotherium: Int?, chorology: JSONNull?, disdiapason: String?, enmarble: JSONNull?, epeira: JSONNull?, eurylaimi: JSONNull?, germination: JSONNull?, hallelujah: JSONNull?, homocerc: Bool?, lev: JSONNull?, mouthing: JSONNull?, nonbookish: JSONNull?, philliloo: JSONNull?, planetal: JSONNull?, poney: JSONNull?, punctualist: JSONNull?, returnlessly: JSONNull?, skelder: JSONNull?, windwaywardly: JSONNull?, yuman: JSONNull?) { + self.alfiona = alfiona + self.ascaridiasis = ascaridiasis + self.bungey = bungey + self.catharticalness = catharticalness + self.ceroxyle = ceroxyle + self.chirotherium = chirotherium + self.chorology = chorology + self.disdiapason = disdiapason + self.enmarble = enmarble + self.epeira = epeira + self.eurylaimi = eurylaimi + self.germination = germination + self.hallelujah = hallelujah + self.homocerc = homocerc + self.lev = lev + self.mouthing = mouthing + self.nonbookish = nonbookish + self.philliloo = philliloo + self.planetal = planetal + self.poney = poney + self.punctualist = punctualist + self.returnlessly = returnlessly + self.skelder = skelder + self.windwaywardly = windwaywardly + self.yuman = yuman + } +} + +// MARK: TruantcyClass convenience initializers and mutators + +extension TruantcyClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(TruantcyClass.self, from: data) + self.init(alfiona: me.alfiona, ascaridiasis: me.ascaridiasis, bungey: me.bungey, catharticalness: me.catharticalness, ceroxyle: me.ceroxyle, chirotherium: me.chirotherium, chorology: me.chorology, disdiapason: me.disdiapason, enmarble: me.enmarble, epeira: me.epeira, eurylaimi: me.eurylaimi, germination: me.germination, hallelujah: me.hallelujah, homocerc: me.homocerc, lev: me.lev, mouthing: me.mouthing, nonbookish: me.nonbookish, philliloo: me.philliloo, planetal: me.planetal, poney: me.poney, punctualist: me.punctualist, returnlessly: me.returnlessly, skelder: me.skelder, windwaywardly: me.windwaywardly, yuman: me.yuman) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + alfiona: JSONNull?? = nil, + ascaridiasis: JSONNull?? = nil, + bungey: JSONNull?? = nil, + catharticalness: Double?? = nil, + ceroxyle: JSONNull?? = nil, + chirotherium: Int?? = nil, + chorology: JSONNull?? = nil, + disdiapason: String?? = nil, + enmarble: JSONNull?? = nil, + epeira: JSONNull?? = nil, + eurylaimi: JSONNull?? = nil, + germination: JSONNull?? = nil, + hallelujah: JSONNull?? = nil, + homocerc: Bool?? = nil, + lev: JSONNull?? = nil, + mouthing: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + philliloo: JSONNull?? = nil, + planetal: JSONNull?? = nil, + poney: JSONNull?? = nil, + punctualist: JSONNull?? = nil, + returnlessly: JSONNull?? = nil, + skelder: JSONNull?? = nil, + windwaywardly: JSONNull?? = nil, + yuman: JSONNull?? = nil + ) -> TruantcyClass { + return TruantcyClass( + alfiona: alfiona ?? self.alfiona, + ascaridiasis: ascaridiasis ?? self.ascaridiasis, + bungey: bungey ?? self.bungey, + catharticalness: catharticalness ?? self.catharticalness, + ceroxyle: ceroxyle ?? self.ceroxyle, + chirotherium: chirotherium ?? self.chirotherium, + chorology: chorology ?? self.chorology, + disdiapason: disdiapason ?? self.disdiapason, + enmarble: enmarble ?? self.enmarble, + epeira: epeira ?? self.epeira, + eurylaimi: eurylaimi ?? self.eurylaimi, + germination: germination ?? self.germination, + hallelujah: hallelujah ?? self.hallelujah, + homocerc: homocerc ?? self.homocerc, + lev: lev ?? self.lev, + mouthing: mouthing ?? self.mouthing, + nonbookish: nonbookish ?? self.nonbookish, + philliloo: philliloo ?? self.philliloo, + planetal: planetal ?? self.planetal, + poney: poney ?? self.poney, + punctualist: punctualist ?? self.punctualist, + returnlessly: returnlessly ?? self.returnlessly, + skelder: skelder ?? self.skelder, + windwaywardly: windwaywardly ?? self.windwaywardly, + yuman: yuman ?? self.yuman + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Unbeginning: Codable { + case integerMap([String: Int]) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Unbeginning.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unbeginning")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Undesirability: Codable { + case integerArray([Int]) + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Undesirability.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Undesirability")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Unerasing: Codable { + case integer(Int) + case integerMap([String: Int]) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Unerasing.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unerasing")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Unguentarium: Codable { + case integer(Int) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Unguentarium.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unguentarium")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum UnimpeachablyElement: Codable { + case bool(Bool) + case unimpeachablyClass(UnimpeachablyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(UnimpeachablyClass.self) { + self = .unimpeachablyClass(x) + return + } + throw DecodingError.typeMismatch(UnimpeachablyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for UnimpeachablyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .unimpeachablyClass(let x): + try container.encode(x) + } + } +} + +// MARK: - UnimpeachablyClass +final class UnimpeachablyClass: Codable { + let acerin: Int? + let bobadil: Int? + let catharticalness: Double? + let chirotherium: Int? + let chlorophylligenous: Int? + let conversational: Int? + let demiowl: Int? + let disdiapason: String? + let ectorhinal: Int? + let gamblesomeness: Int? + let homocerc: Bool? + let irrorate: Int? + let kindergartening: Int? + let lateritic: Int? + let mespil: Int? + let misconfiguration: Int? + let nonbookish: JSONNull? + let planometry: Int? + let quiina: Int? + let robert: Int? + let rot: Int? + let subcinctorium: Int? + let tussocker: Int? + let ultraproud: Int? + let unsuggestedness: Int? + + enum CodingKeys: String, CodingKey { + case acerin = "acerin" + case bobadil = "Bobadil" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case chlorophylligenous = "chlorophylligenous" + case conversational = "conversational" + case demiowl = "demiowl" + case disdiapason = "disdiapason" + case ectorhinal = "ectorhinal" + case gamblesomeness = "gamblesomeness" + case homocerc = "homocerc" + case irrorate = "irrorate" + case kindergartening = "kindergartening" + case lateritic = "lateritic" + case mespil = "mespil" + case misconfiguration = "misconfiguration" + case nonbookish = "nonbookish" + case planometry = "planometry" + case quiina = "Quiina" + case robert = "Robert" + case rot = "rot" + case subcinctorium = "subcinctorium" + case tussocker = "tussocker" + case ultraproud = "ultraproud" + case unsuggestedness = "unsuggestedness" + } + + init(acerin: Int?, bobadil: Int?, catharticalness: Double?, chirotherium: Int?, chlorophylligenous: Int?, conversational: Int?, demiowl: Int?, disdiapason: String?, ectorhinal: Int?, gamblesomeness: Int?, homocerc: Bool?, irrorate: Int?, kindergartening: Int?, lateritic: Int?, mespil: Int?, misconfiguration: Int?, nonbookish: JSONNull?, planometry: Int?, quiina: Int?, robert: Int?, rot: Int?, subcinctorium: Int?, tussocker: Int?, ultraproud: Int?, unsuggestedness: Int?) { + self.acerin = acerin + self.bobadil = bobadil + self.catharticalness = catharticalness + self.chirotherium = chirotherium + self.chlorophylligenous = chlorophylligenous + self.conversational = conversational + self.demiowl = demiowl + self.disdiapason = disdiapason + self.ectorhinal = ectorhinal + self.gamblesomeness = gamblesomeness + self.homocerc = homocerc + self.irrorate = irrorate + self.kindergartening = kindergartening + self.lateritic = lateritic + self.mespil = mespil + self.misconfiguration = misconfiguration + self.nonbookish = nonbookish + self.planometry = planometry + self.quiina = quiina + self.robert = robert + self.rot = rot + self.subcinctorium = subcinctorium + self.tussocker = tussocker + self.ultraproud = ultraproud + self.unsuggestedness = unsuggestedness + } +} + +// MARK: UnimpeachablyClass convenience initializers and mutators + +extension UnimpeachablyClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(UnimpeachablyClass.self, from: data) + self.init(acerin: me.acerin, bobadil: me.bobadil, catharticalness: me.catharticalness, chirotherium: me.chirotherium, chlorophylligenous: me.chlorophylligenous, conversational: me.conversational, demiowl: me.demiowl, disdiapason: me.disdiapason, ectorhinal: me.ectorhinal, gamblesomeness: me.gamblesomeness, homocerc: me.homocerc, irrorate: me.irrorate, kindergartening: me.kindergartening, lateritic: me.lateritic, mespil: me.mespil, misconfiguration: me.misconfiguration, nonbookish: me.nonbookish, planometry: me.planometry, quiina: me.quiina, robert: me.robert, rot: me.rot, subcinctorium: me.subcinctorium, tussocker: me.tussocker, ultraproud: me.ultraproud, unsuggestedness: me.unsuggestedness) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acerin: Int?? = nil, + bobadil: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + chlorophylligenous: Int?? = nil, + conversational: Int?? = nil, + demiowl: Int?? = nil, + disdiapason: String?? = nil, + ectorhinal: Int?? = nil, + gamblesomeness: Int?? = nil, + homocerc: Bool?? = nil, + irrorate: Int?? = nil, + kindergartening: Int?? = nil, + lateritic: Int?? = nil, + mespil: Int?? = nil, + misconfiguration: Int?? = nil, + nonbookish: JSONNull?? = nil, + planometry: Int?? = nil, + quiina: Int?? = nil, + robert: Int?? = nil, + rot: Int?? = nil, + subcinctorium: Int?? = nil, + tussocker: Int?? = nil, + ultraproud: Int?? = nil, + unsuggestedness: Int?? = nil + ) -> UnimpeachablyClass { + return UnimpeachablyClass( + acerin: acerin ?? self.acerin, + bobadil: bobadil ?? self.bobadil, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + chlorophylligenous: chlorophylligenous ?? self.chlorophylligenous, + conversational: conversational ?? self.conversational, + demiowl: demiowl ?? self.demiowl, + disdiapason: disdiapason ?? self.disdiapason, + ectorhinal: ectorhinal ?? self.ectorhinal, + gamblesomeness: gamblesomeness ?? self.gamblesomeness, + homocerc: homocerc ?? self.homocerc, + irrorate: irrorate ?? self.irrorate, + kindergartening: kindergartening ?? self.kindergartening, + lateritic: lateritic ?? self.lateritic, + mespil: mespil ?? self.mespil, + misconfiguration: misconfiguration ?? self.misconfiguration, + nonbookish: nonbookish ?? self.nonbookish, + planometry: planometry ?? self.planometry, + quiina: quiina ?? self.quiina, + robert: robert ?? self.robert, + rot: rot ?? self.rot, + subcinctorium: subcinctorium ?? self.subcinctorium, + tussocker: tussocker ?? self.tussocker, + ultraproud: ultraproud ?? self.ultraproud, + unsuggestedness: unsuggestedness ?? self.unsuggestedness + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Unmortgaged: Codable { + case double(Double) + case integerMap([String: Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Unmortgaged.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unmortgaged")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Unobstructed: Codable { + case integer(Int) + case quebrachineClass(QuebrachineClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Unobstructed.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unobstructed")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Unreceptivity: Codable { + case integer(Int) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Unreceptivity.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unreceptivity")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Unsatisfactoriness: Codable { + case bool(Bool) + case integer(Int) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + throw DecodingError.typeMismatch(Unsatisfactoriness.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unsatisfactoriness")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +enum UnstressedElement: Codable { + case bool(Bool) + case string(String) + case unstressedClass(UnstressedClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(UnstressedClass.self) { + self = .unstressedClass(x) + return + } + throw DecodingError.typeMismatch(UnstressedElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for UnstressedElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .unstressedClass(let x): + try container.encode(x) + } + } +} + +// MARK: - UnstressedClass +final class UnstressedClass: Codable { + let alain: JSONNull? + let amphirhina: JSONNull? + let antimachinery: JSONNull? + let coldish: JSONNull? + let crantara: JSONNull? + let distinguishing: JSONNull? + let elytroposis: JSONNull? + let gentianwort: JSONNull? + let heliosis: JSONNull? + let instrumental: JSONNull? + let introinflection: JSONNull? + let kala: JSONNull? + let lincolnian: JSONNull? + let metad: JSONNull? + let sarcophilus: JSONNull? + let swingingly: JSONNull? + let unconformity: JSONNull? + let undecreed: JSONNull? + let venerable: JSONNull? + let vowellessness: JSONNull? + + enum CodingKeys: String, CodingKey { + case alain = "Alain" + case amphirhina = "Amphirhina" + case antimachinery = "antimachinery" + case coldish = "coldish" + case crantara = "crantara" + case distinguishing = "distinguishing" + case elytroposis = "elytroposis" + case gentianwort = "gentianwort" + case heliosis = "heliosis" + case instrumental = "instrumental" + case introinflection = "introinflection" + case kala = "kala" + case lincolnian = "Lincolnian" + case metad = "metad" + case sarcophilus = "Sarcophilus" + case swingingly = "swingingly" + case unconformity = "unconformity" + case undecreed = "undecreed" + case venerable = "venerable" + case vowellessness = "vowellessness" + } + + init(alain: JSONNull?, amphirhina: JSONNull?, antimachinery: JSONNull?, coldish: JSONNull?, crantara: JSONNull?, distinguishing: JSONNull?, elytroposis: JSONNull?, gentianwort: JSONNull?, heliosis: JSONNull?, instrumental: JSONNull?, introinflection: JSONNull?, kala: JSONNull?, lincolnian: JSONNull?, metad: JSONNull?, sarcophilus: JSONNull?, swingingly: JSONNull?, unconformity: JSONNull?, undecreed: JSONNull?, venerable: JSONNull?, vowellessness: JSONNull?) { + self.alain = alain + self.amphirhina = amphirhina + self.antimachinery = antimachinery + self.coldish = coldish + self.crantara = crantara + self.distinguishing = distinguishing + self.elytroposis = elytroposis + self.gentianwort = gentianwort + self.heliosis = heliosis + self.instrumental = instrumental + self.introinflection = introinflection + self.kala = kala + self.lincolnian = lincolnian + self.metad = metad + self.sarcophilus = sarcophilus + self.swingingly = swingingly + self.unconformity = unconformity + self.undecreed = undecreed + self.venerable = venerable + self.vowellessness = vowellessness + } +} + +// MARK: UnstressedClass convenience initializers and mutators + +extension UnstressedClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(UnstressedClass.self, from: data) + self.init(alain: me.alain, amphirhina: me.amphirhina, antimachinery: me.antimachinery, coldish: me.coldish, crantara: me.crantara, distinguishing: me.distinguishing, elytroposis: me.elytroposis, gentianwort: me.gentianwort, heliosis: me.heliosis, instrumental: me.instrumental, introinflection: me.introinflection, kala: me.kala, lincolnian: me.lincolnian, metad: me.metad, sarcophilus: me.sarcophilus, swingingly: me.swingingly, unconformity: me.unconformity, undecreed: me.undecreed, venerable: me.venerable, vowellessness: me.vowellessness) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + alain: JSONNull?? = nil, + amphirhina: JSONNull?? = nil, + antimachinery: JSONNull?? = nil, + coldish: JSONNull?? = nil, + crantara: JSONNull?? = nil, + distinguishing: JSONNull?? = nil, + elytroposis: JSONNull?? = nil, + gentianwort: JSONNull?? = nil, + heliosis: JSONNull?? = nil, + instrumental: JSONNull?? = nil, + introinflection: JSONNull?? = nil, + kala: JSONNull?? = nil, + lincolnian: JSONNull?? = nil, + metad: JSONNull?? = nil, + sarcophilus: JSONNull?? = nil, + swingingly: JSONNull?? = nil, + unconformity: JSONNull?? = nil, + undecreed: JSONNull?? = nil, + venerable: JSONNull?? = nil, + vowellessness: JSONNull?? = nil + ) -> UnstressedClass { + return UnstressedClass( + alain: alain ?? self.alain, + amphirhina: amphirhina ?? self.amphirhina, + antimachinery: antimachinery ?? self.antimachinery, + coldish: coldish ?? self.coldish, + crantara: crantara ?? self.crantara, + distinguishing: distinguishing ?? self.distinguishing, + elytroposis: elytroposis ?? self.elytroposis, + gentianwort: gentianwort ?? self.gentianwort, + heliosis: heliosis ?? self.heliosis, + instrumental: instrumental ?? self.instrumental, + introinflection: introinflection ?? self.introinflection, + kala: kala ?? self.kala, + lincolnian: lincolnian ?? self.lincolnian, + metad: metad ?? self.metad, + sarcophilus: sarcophilus ?? self.sarcophilus, + swingingly: swingingly ?? self.swingingly, + unconformity: unconformity ?? self.unconformity, + undecreed: undecreed ?? self.undecreed, + venerable: venerable ?? self.venerable, + vowellessness: vowellessness ?? self.vowellessness + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Untasked: Codable { + case double(Double) + case integerMap([String: Int]) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Untasked.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Untasked")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Unvarying: Codable { + case bool(Bool) + case double(Double) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Unvarying.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unvarying")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Vehemently: Codable { + case bool(Bool) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Vehemently.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Vehemently")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Whitepot: Codable { + case double(Double) + case quebrachineClass(QuebrachineClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + throw DecodingError.typeMismatch(Whitepot.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Whitepot")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + } + } +} + +enum WrothyElement: Codable { + case nullArray([JSONNull?]) + case wrothyClass(WrothyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(WrothyClass.self) { + self = .wrothyClass(x) + return + } + throw DecodingError.typeMismatch(WrothyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for WrothyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .wrothyClass(let x): + try container.encode(x) + } + } +} + +// MARK: - WrothyClass +final class WrothyClass: Codable { + let aeschynanthus: JSONNull? + let aquiferous: JSONNull? + let cheapener: JSONNull? + let enumeration: JSONNull? + let ephesine: JSONNull? + let escadrille: JSONNull? + let estrous: JSONNull? + let interestedly: JSONNull? + let katakinetomer: JSONNull? + let mortification: JSONNull? + let morula: JSONNull? + let orthosymmetrical: JSONNull? + let overbark: JSONNull? + let politist: JSONNull? + let qualified: JSONNull? + let sphenomalar: JSONNull? + let throatful: JSONNull? + let transhumance: JSONNull? + let triandrian: JSONNull? + let unbooked: JSONNull? + + enum CodingKeys: String, CodingKey { + case aeschynanthus = "Aeschynanthus" + case aquiferous = "aquiferous" + case cheapener = "cheapener" + case enumeration = "enumeration" + case ephesine = "Ephesine" + case escadrille = "escadrille" + case estrous = "estrous" + case interestedly = "interestedly" + case katakinetomer = "katakinetomer" + case mortification = "mortification" + case morula = "morula" + case orthosymmetrical = "orthosymmetrical" + case overbark = "overbark" + case politist = "politist" + case qualified = "qualified" + case sphenomalar = "sphenomalar" + case throatful = "throatful" + case transhumance = "transhumance" + case triandrian = "triandrian" + case unbooked = "unbooked" + } + + init(aeschynanthus: JSONNull?, aquiferous: JSONNull?, cheapener: JSONNull?, enumeration: JSONNull?, ephesine: JSONNull?, escadrille: JSONNull?, estrous: JSONNull?, interestedly: JSONNull?, katakinetomer: JSONNull?, mortification: JSONNull?, morula: JSONNull?, orthosymmetrical: JSONNull?, overbark: JSONNull?, politist: JSONNull?, qualified: JSONNull?, sphenomalar: JSONNull?, throatful: JSONNull?, transhumance: JSONNull?, triandrian: JSONNull?, unbooked: JSONNull?) { + self.aeschynanthus = aeschynanthus + self.aquiferous = aquiferous + self.cheapener = cheapener + self.enumeration = enumeration + self.ephesine = ephesine + self.escadrille = escadrille + self.estrous = estrous + self.interestedly = interestedly + self.katakinetomer = katakinetomer + self.mortification = mortification + self.morula = morula + self.orthosymmetrical = orthosymmetrical + self.overbark = overbark + self.politist = politist + self.qualified = qualified + self.sphenomalar = sphenomalar + self.throatful = throatful + self.transhumance = transhumance + self.triandrian = triandrian + self.unbooked = unbooked + } +} + +// MARK: WrothyClass convenience initializers and mutators + +extension WrothyClass { + convenience init(data: Data) throws { + let me = try newJSONDecoder().decode(WrothyClass.self, from: data) + self.init(aeschynanthus: me.aeschynanthus, aquiferous: me.aquiferous, cheapener: me.cheapener, enumeration: me.enumeration, ephesine: me.ephesine, escadrille: me.escadrille, estrous: me.estrous, interestedly: me.interestedly, katakinetomer: me.katakinetomer, mortification: me.mortification, morula: me.morula, orthosymmetrical: me.orthosymmetrical, overbark: me.overbark, politist: me.politist, qualified: me.qualified, sphenomalar: me.sphenomalar, throatful: me.throatful, transhumance: me.transhumance, triandrian: me.triandrian, unbooked: me.unbooked) + } + + convenience init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + convenience init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + aeschynanthus: JSONNull?? = nil, + aquiferous: JSONNull?? = nil, + cheapener: JSONNull?? = nil, + enumeration: JSONNull?? = nil, + ephesine: JSONNull?? = nil, + escadrille: JSONNull?? = nil, + estrous: JSONNull?? = nil, + interestedly: JSONNull?? = nil, + katakinetomer: JSONNull?? = nil, + mortification: JSONNull?? = nil, + morula: JSONNull?? = nil, + orthosymmetrical: JSONNull?? = nil, + overbark: JSONNull?? = nil, + politist: JSONNull?? = nil, + qualified: JSONNull?? = nil, + sphenomalar: JSONNull?? = nil, + throatful: JSONNull?? = nil, + transhumance: JSONNull?? = nil, + triandrian: JSONNull?? = nil, + unbooked: JSONNull?? = nil + ) -> WrothyClass { + return WrothyClass( + aeschynanthus: aeschynanthus ?? self.aeschynanthus, + aquiferous: aquiferous ?? self.aquiferous, + cheapener: cheapener ?? self.cheapener, + enumeration: enumeration ?? self.enumeration, + ephesine: ephesine ?? self.ephesine, + escadrille: escadrille ?? self.escadrille, + estrous: estrous ?? self.estrous, + interestedly: interestedly ?? self.interestedly, + katakinetomer: katakinetomer ?? self.katakinetomer, + mortification: mortification ?? self.mortification, + morula: morula ?? self.morula, + orthosymmetrical: orthosymmetrical ?? self.orthosymmetrical, + overbark: overbark ?? self.overbark, + politist: politist ?? self.politist, + qualified: qualified ?? self.qualified, + sphenomalar: sphenomalar ?? self.sphenomalar, + throatful: throatful ?? self.throatful, + transhumance: transhumance ?? self.transhumance, + triandrian: triandrian ?? self.triandrian, + unbooked: unbooked ?? self.unbooked + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Helper functions for creating encoders and decoders + +func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder +} + +func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// MARK: - Encode/decode helpers + +final class JSONNull: Codable, Hashable { + + public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool { + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(0) + } + + public init() {} + + public required init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if !container.decodeNil() { + throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull")) + } + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + try container.encodeNil() + } +} diff --git a/head/swift/test/inputs/json/priority/combinations4.json/protocol-hashable--739b516c7897/quicktype.swift b/head/swift/test/inputs/json/priority/combinations4.json/protocol-hashable--739b516c7897/quicktype.swift new file mode 100644 index 0000000..dac23fd --- /dev/null +++ b/head/swift/test/inputs/json/priority/combinations4.json/protocol-hashable--739b516c7897/quicktype.swift @@ -0,0 +1,3743 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +import Foundation + +// MARK: - TopLevel +struct TopLevel: Codable, Hashable { + let protrusive: [Protrusive] + let pulpitism: [PulpitismElement] + let pyodermia: [PyodermiaElement] + let quebrachine: [QuebrachineElement] + let querier: [Querier] + let rebarbative: [Rebarbative] + let reimagine: [Reimagine] + let ressaut: Ressaut + let retrocervical: [Retrocervical] + let revert: [Revert] + let rewrite: [RewriteElement] + let saccoderm: [Saccoderm] + let santir: [SantirElement] + let saprophilous: [Saprophilous] + let saxten: [SaxtenElement] + let scatty: [Scatty?] + let scoffer: [Scoffer] + let scrampum: [Scrampum] + let semantic: Double + let serpentinic: [Serpentinic] + let shadowable: [Shadowable] + let sistering: [SisteringElement] + let staghunting: [Staghunting] + let stagmometer: [Stagmometer] + let stimulability: [Stimulability] + let strangleable: [Strangleable] + let strenuosity: [StrenuosityElement] + let tabaxir: [Tabaxir] + let talpiform: [Talpiform] + let thwack: [Thwack] + let to: [Double?] + let tortricine: [Tortricine] + let truantcy: [TruantcyElement] + let turgesce: [String] + let unbeginning: [Unbeginning] + let underdunged: [Double] + let undesirability: [Undesirability] + let unerasing: [Unerasing] + let unguentarium: [Unguentarium] + let unimpeachably: [UnimpeachablyElement] + let unmortgaged: [Unmortgaged] + let unobstructed: [Unobstructed] + let unreceptivity: [Unreceptivity] + let unsatisfactoriness: [Unsatisfactoriness] + let unsecurity: [Int] + let unstressed: [UnstressedElement] + let untasked: [Untasked] + let unvarying: [Unvarying] + let vehemently: [Vehemently] + let warriorship: [String: Bool] + let whitepot: [Whitepot] + let wrothy: [WrothyElement] + + enum CodingKeys: String, CodingKey { + case protrusive = "protrusive" + case pulpitism = "pulpitism" + case pyodermia = "pyodermia" + case quebrachine = "quebrachine" + case querier = "querier" + case rebarbative = "rebarbative" + case reimagine = "reimagine" + case ressaut = "ressaut" + case retrocervical = "retrocervical" + case revert = "revert" + case rewrite = "rewrite" + case saccoderm = "saccoderm" + case santir = "santir" + case saprophilous = "saprophilous" + case saxten = "saxten" + case scatty = "scatty" + case scoffer = "scoffer" + case scrampum = "scrampum" + case semantic = "semantic" + case serpentinic = "serpentinic" + case shadowable = "shadowable" + case sistering = "sistering" + case staghunting = "staghunting" + case stagmometer = "stagmometer" + case stimulability = "stimulability" + case strangleable = "strangleable" + case strenuosity = "strenuosity" + case tabaxir = "tabaxir" + case talpiform = "talpiform" + case thwack = "thwack" + case to = "to" + case tortricine = "tortricine" + case truantcy = "truantcy" + case turgesce = "turgesce" + case unbeginning = "unbeginning" + case underdunged = "underdunged" + case undesirability = "undesirability" + case unerasing = "unerasing" + case unguentarium = "unguentarium" + case unimpeachably = "unimpeachably" + case unmortgaged = "unmortgaged" + case unobstructed = "unobstructed" + case unreceptivity = "unreceptivity" + case unsatisfactoriness = "unsatisfactoriness" + case unsecurity = "unsecurity" + case unstressed = "unstressed" + case untasked = "untasked" + case unvarying = "unvarying" + case vehemently = "vehemently" + case warriorship = "warriorship" + case whitepot = "whitepot" + case wrothy = "wrothy" + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + init(data: Data) throws { + self = try newJSONDecoder().decode(TopLevel.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + protrusive: [Protrusive]? = nil, + pulpitism: [PulpitismElement]? = nil, + pyodermia: [PyodermiaElement]? = nil, + quebrachine: [QuebrachineElement]? = nil, + querier: [Querier]? = nil, + rebarbative: [Rebarbative]? = nil, + reimagine: [Reimagine]? = nil, + ressaut: Ressaut? = nil, + retrocervical: [Retrocervical]? = nil, + revert: [Revert]? = nil, + rewrite: [RewriteElement]? = nil, + saccoderm: [Saccoderm]? = nil, + santir: [SantirElement]? = nil, + saprophilous: [Saprophilous]? = nil, + saxten: [SaxtenElement]? = nil, + scatty: [Scatty?]? = nil, + scoffer: [Scoffer]? = nil, + scrampum: [Scrampum]? = nil, + semantic: Double? = nil, + serpentinic: [Serpentinic]? = nil, + shadowable: [Shadowable]? = nil, + sistering: [SisteringElement]? = nil, + staghunting: [Staghunting]? = nil, + stagmometer: [Stagmometer]? = nil, + stimulability: [Stimulability]? = nil, + strangleable: [Strangleable]? = nil, + strenuosity: [StrenuosityElement]? = nil, + tabaxir: [Tabaxir]? = nil, + talpiform: [Talpiform]? = nil, + thwack: [Thwack]? = nil, + to: [Double?]? = nil, + tortricine: [Tortricine]? = nil, + truantcy: [TruantcyElement]? = nil, + turgesce: [String]? = nil, + unbeginning: [Unbeginning]? = nil, + underdunged: [Double]? = nil, + undesirability: [Undesirability]? = nil, + unerasing: [Unerasing]? = nil, + unguentarium: [Unguentarium]? = nil, + unimpeachably: [UnimpeachablyElement]? = nil, + unmortgaged: [Unmortgaged]? = nil, + unobstructed: [Unobstructed]? = nil, + unreceptivity: [Unreceptivity]? = nil, + unsatisfactoriness: [Unsatisfactoriness]? = nil, + unsecurity: [Int]? = nil, + unstressed: [UnstressedElement]? = nil, + untasked: [Untasked]? = nil, + unvarying: [Unvarying]? = nil, + vehemently: [Vehemently]? = nil, + warriorship: [String: Bool]? = nil, + whitepot: [Whitepot]? = nil, + wrothy: [WrothyElement]? = nil + ) -> TopLevel { + return TopLevel( + protrusive: protrusive ?? self.protrusive, + pulpitism: pulpitism ?? self.pulpitism, + pyodermia: pyodermia ?? self.pyodermia, + quebrachine: quebrachine ?? self.quebrachine, + querier: querier ?? self.querier, + rebarbative: rebarbative ?? self.rebarbative, + reimagine: reimagine ?? self.reimagine, + ressaut: ressaut ?? self.ressaut, + retrocervical: retrocervical ?? self.retrocervical, + revert: revert ?? self.revert, + rewrite: rewrite ?? self.rewrite, + saccoderm: saccoderm ?? self.saccoderm, + santir: santir ?? self.santir, + saprophilous: saprophilous ?? self.saprophilous, + saxten: saxten ?? self.saxten, + scatty: scatty ?? self.scatty, + scoffer: scoffer ?? self.scoffer, + scrampum: scrampum ?? self.scrampum, + semantic: semantic ?? self.semantic, + serpentinic: serpentinic ?? self.serpentinic, + shadowable: shadowable ?? self.shadowable, + sistering: sistering ?? self.sistering, + staghunting: staghunting ?? self.staghunting, + stagmometer: stagmometer ?? self.stagmometer, + stimulability: stimulability ?? self.stimulability, + strangleable: strangleable ?? self.strangleable, + strenuosity: strenuosity ?? self.strenuosity, + tabaxir: tabaxir ?? self.tabaxir, + talpiform: talpiform ?? self.talpiform, + thwack: thwack ?? self.thwack, + to: to ?? self.to, + tortricine: tortricine ?? self.tortricine, + truantcy: truantcy ?? self.truantcy, + turgesce: turgesce ?? self.turgesce, + unbeginning: unbeginning ?? self.unbeginning, + underdunged: underdunged ?? self.underdunged, + undesirability: undesirability ?? self.undesirability, + unerasing: unerasing ?? self.unerasing, + unguentarium: unguentarium ?? self.unguentarium, + unimpeachably: unimpeachably ?? self.unimpeachably, + unmortgaged: unmortgaged ?? self.unmortgaged, + unobstructed: unobstructed ?? self.unobstructed, + unreceptivity: unreceptivity ?? self.unreceptivity, + unsatisfactoriness: unsatisfactoriness ?? self.unsatisfactoriness, + unsecurity: unsecurity ?? self.unsecurity, + unstressed: unstressed ?? self.unstressed, + untasked: untasked ?? self.untasked, + unvarying: unvarying ?? self.unvarying, + vehemently: vehemently ?? self.vehemently, + warriorship: warriorship ?? self.warriorship, + whitepot: whitepot ?? self.whitepot, + wrothy: wrothy ?? self.wrothy + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Protrusive: Codable, Hashable { + case double(Double) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Protrusive.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Protrusive")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +enum PulpitismElement: Codable, Hashable { + case double(Double) + case integerArray([Int]) + case pulpitismClass(PulpitismClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(PulpitismClass.self) { + self = .pulpitismClass(x) + return + } + throw DecodingError.typeMismatch(PulpitismElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PulpitismElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .pulpitismClass(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - PulpitismClass +struct PulpitismClass: Codable, Hashable { + let abnet: JSONNull? + let buckhorn: JSONNull? + let calciform: JSONNull? + let chelophore: JSONNull? + let cogitation: JSONNull? + let decreeable: JSONNull? + let despicable: JSONNull? + let isodiazo: JSONNull? + let jadedly: JSONNull? + let leptochlorite: JSONNull? + let nursling: JSONNull? + let palamedean: JSONNull? + let photoheliograph: JSONNull? + let pipewood: JSONNull? + let roberd: JSONNull? + let statable: JSONNull? + let superassume: JSONNull? + let syllabe: JSONNull? + let toughhead: JSONNull? + let underburn: JSONNull? + + enum CodingKeys: String, CodingKey { + case abnet = "abnet" + case buckhorn = "buckhorn" + case calciform = "calciform" + case chelophore = "chelophore" + case cogitation = "cogitation" + case decreeable = "decreeable" + case despicable = "despicable" + case isodiazo = "isodiazo" + case jadedly = "jadedly" + case leptochlorite = "leptochlorite" + case nursling = "nursling" + case palamedean = "palamedean" + case photoheliograph = "photoheliograph" + case pipewood = "pipewood" + case roberd = "roberd" + case statable = "statable" + case superassume = "superassume" + case syllabe = "syllabe" + case toughhead = "toughhead" + case underburn = "underburn" + } +} + +// MARK: PulpitismClass convenience initializers and mutators + +extension PulpitismClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(PulpitismClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + abnet: JSONNull?? = nil, + buckhorn: JSONNull?? = nil, + calciform: JSONNull?? = nil, + chelophore: JSONNull?? = nil, + cogitation: JSONNull?? = nil, + decreeable: JSONNull?? = nil, + despicable: JSONNull?? = nil, + isodiazo: JSONNull?? = nil, + jadedly: JSONNull?? = nil, + leptochlorite: JSONNull?? = nil, + nursling: JSONNull?? = nil, + palamedean: JSONNull?? = nil, + photoheliograph: JSONNull?? = nil, + pipewood: JSONNull?? = nil, + roberd: JSONNull?? = nil, + statable: JSONNull?? = nil, + superassume: JSONNull?? = nil, + syllabe: JSONNull?? = nil, + toughhead: JSONNull?? = nil, + underburn: JSONNull?? = nil + ) -> PulpitismClass { + return PulpitismClass( + abnet: abnet ?? self.abnet, + buckhorn: buckhorn ?? self.buckhorn, + calciform: calciform ?? self.calciform, + chelophore: chelophore ?? self.chelophore, + cogitation: cogitation ?? self.cogitation, + decreeable: decreeable ?? self.decreeable, + despicable: despicable ?? self.despicable, + isodiazo: isodiazo ?? self.isodiazo, + jadedly: jadedly ?? self.jadedly, + leptochlorite: leptochlorite ?? self.leptochlorite, + nursling: nursling ?? self.nursling, + palamedean: palamedean ?? self.palamedean, + photoheliograph: photoheliograph ?? self.photoheliograph, + pipewood: pipewood ?? self.pipewood, + roberd: roberd ?? self.roberd, + statable: statable ?? self.statable, + superassume: superassume ?? self.superassume, + syllabe: syllabe ?? self.syllabe, + toughhead: toughhead ?? self.toughhead, + underburn: underburn ?? self.underburn + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum PyodermiaElement: Codable, Hashable { + case integer(Int) + case pyodermiaClass(PyodermiaClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(PyodermiaClass.self) { + self = .pyodermiaClass(x) + return + } + throw DecodingError.typeMismatch(PyodermiaElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for PyodermiaElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .pyodermiaClass(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - PyodermiaClass +struct PyodermiaClass: Codable, Hashable { + let aphoristically: JSONNull? + let apophyllous: JSONNull? + let cognize: JSONNull? + let dermonosology: JSONNull? + let gyppo: JSONNull? + let ither: JSONNull? + let juglandaceous: JSONNull? + let litho: JSONNull? + let macropterous: JSONNull? + let photographer: JSONNull? + let romancing: JSONNull? + let rumness: JSONNull? + let somniloquist: JSONNull? + let stressfully: JSONNull? + let tactically: JSONNull? + let tracheophony: JSONNull? + let unappositely: JSONNull? + let unclothedly: JSONNull? + let unimplied: JSONNull? + let unsyncopated: JSONNull? + + enum CodingKeys: String, CodingKey { + case aphoristically = "aphoristically" + case apophyllous = "apophyllous" + case cognize = "cognize" + case dermonosology = "dermonosology" + case gyppo = "Gyppo" + case ither = "ither" + case juglandaceous = "juglandaceous" + case litho = "litho" + case macropterous = "macropterous" + case photographer = "photographer" + case romancing = "romancing" + case rumness = "rumness" + case somniloquist = "somniloquist" + case stressfully = "stressfully" + case tactically = "tactically" + case tracheophony = "tracheophony" + case unappositely = "unappositely" + case unclothedly = "unclothedly" + case unimplied = "unimplied" + case unsyncopated = "unsyncopated" + } +} + +// MARK: PyodermiaClass convenience initializers and mutators + +extension PyodermiaClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(PyodermiaClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + aphoristically: JSONNull?? = nil, + apophyllous: JSONNull?? = nil, + cognize: JSONNull?? = nil, + dermonosology: JSONNull?? = nil, + gyppo: JSONNull?? = nil, + ither: JSONNull?? = nil, + juglandaceous: JSONNull?? = nil, + litho: JSONNull?? = nil, + macropterous: JSONNull?? = nil, + photographer: JSONNull?? = nil, + romancing: JSONNull?? = nil, + rumness: JSONNull?? = nil, + somniloquist: JSONNull?? = nil, + stressfully: JSONNull?? = nil, + tactically: JSONNull?? = nil, + tracheophony: JSONNull?? = nil, + unappositely: JSONNull?? = nil, + unclothedly: JSONNull?? = nil, + unimplied: JSONNull?? = nil, + unsyncopated: JSONNull?? = nil + ) -> PyodermiaClass { + return PyodermiaClass( + aphoristically: aphoristically ?? self.aphoristically, + apophyllous: apophyllous ?? self.apophyllous, + cognize: cognize ?? self.cognize, + dermonosology: dermonosology ?? self.dermonosology, + gyppo: gyppo ?? self.gyppo, + ither: ither ?? self.ither, + juglandaceous: juglandaceous ?? self.juglandaceous, + litho: litho ?? self.litho, + macropterous: macropterous ?? self.macropterous, + photographer: photographer ?? self.photographer, + romancing: romancing ?? self.romancing, + rumness: rumness ?? self.rumness, + somniloquist: somniloquist ?? self.somniloquist, + stressfully: stressfully ?? self.stressfully, + tactically: tactically ?? self.tactically, + tracheophony: tracheophony ?? self.tracheophony, + unappositely: unappositely ?? self.unappositely, + unclothedly: unclothedly ?? self.unclothedly, + unimplied: unimplied ?? self.unimplied, + unsyncopated: unsyncopated ?? self.unsyncopated + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum QuebrachineElement: Codable, Hashable { + case bool(Bool) + case quebrachineClass(QuebrachineClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(QuebrachineElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for QuebrachineElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - QuebrachineClass +struct QuebrachineClass: Codable, Hashable { + let catharticalness: Double + let chirotherium: Int + let disdiapason: String + let homocerc: Bool + let nonbookish: JSONNull? + + enum CodingKeys: String, CodingKey { + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case homocerc = "homocerc" + case nonbookish = "nonbookish" + } +} + +// MARK: QuebrachineClass convenience initializers and mutators + +extension QuebrachineClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(QuebrachineClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + catharticalness: Double? = nil, + chirotherium: Int? = nil, + disdiapason: String? = nil, + homocerc: Bool? = nil, + nonbookish: JSONNull?? = nil + ) -> QuebrachineClass { + return QuebrachineClass( + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + homocerc: homocerc ?? self.homocerc, + nonbookish: nonbookish ?? self.nonbookish + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Querier: Codable, Hashable { + case bool(Bool) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Querier.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Querier")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Rebarbative: Codable, Hashable { + case bool(Bool) + case double(Double) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Rebarbative.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Rebarbative")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - Reimagine +struct Reimagine: Codable, Hashable { + let adducible: JSONNull? + let anabolin: JSONNull? + let brainy: JSONNull? + let catharticalness: Double? + let chirotherium: Int? + let chrysamine: JSONNull? + let disdiapason: String? + let fluxweed: JSONNull? + let glaucine: JSONNull? + let grobianism: JSONNull? + let hermo: JSONNull? + let hieroglyphist: JSONNull? + let homocerc: Bool? + let icteroid: JSONNull? + let immortal: JSONNull? + let impetulant: JSONNull? + let irrigate: JSONNull? + let myxedema: JSONNull? + let nonbookish: JSONNull? + let onyx: JSONNull? + let repasser: JSONNull? + let septomarginal: JSONNull? + let subdie: JSONNull? + let tibiometatarsal: JSONNull? + let waltzlike: JSONNull? + + enum CodingKeys: String, CodingKey { + case adducible = "adducible" + case anabolin = "anabolin" + case brainy = "brainy" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case chrysamine = "chrysamine" + case disdiapason = "disdiapason" + case fluxweed = "fluxweed" + case glaucine = "glaucine" + case grobianism = "grobianism" + case hermo = "Hermo" + case hieroglyphist = "hieroglyphist" + case homocerc = "homocerc" + case icteroid = "icteroid" + case immortal = "immortal" + case impetulant = "impetulant" + case irrigate = "irrigate" + case myxedema = "myxedema" + case nonbookish = "nonbookish" + case onyx = "onyx" + case repasser = "repasser" + case septomarginal = "septomarginal" + case subdie = "subdie" + case tibiometatarsal = "tibiometatarsal" + case waltzlike = "waltzlike" + } +} + +// MARK: Reimagine convenience initializers and mutators + +extension Reimagine { + init(data: Data) throws { + self = try newJSONDecoder().decode(Reimagine.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + adducible: JSONNull?? = nil, + anabolin: JSONNull?? = nil, + brainy: JSONNull?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + chrysamine: JSONNull?? = nil, + disdiapason: String?? = nil, + fluxweed: JSONNull?? = nil, + glaucine: JSONNull?? = nil, + grobianism: JSONNull?? = nil, + hermo: JSONNull?? = nil, + hieroglyphist: JSONNull?? = nil, + homocerc: Bool?? = nil, + icteroid: JSONNull?? = nil, + immortal: JSONNull?? = nil, + impetulant: JSONNull?? = nil, + irrigate: JSONNull?? = nil, + myxedema: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + onyx: JSONNull?? = nil, + repasser: JSONNull?? = nil, + septomarginal: JSONNull?? = nil, + subdie: JSONNull?? = nil, + tibiometatarsal: JSONNull?? = nil, + waltzlike: JSONNull?? = nil + ) -> Reimagine { + return Reimagine( + adducible: adducible ?? self.adducible, + anabolin: anabolin ?? self.anabolin, + brainy: brainy ?? self.brainy, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + chrysamine: chrysamine ?? self.chrysamine, + disdiapason: disdiapason ?? self.disdiapason, + fluxweed: fluxweed ?? self.fluxweed, + glaucine: glaucine ?? self.glaucine, + grobianism: grobianism ?? self.grobianism, + hermo: hermo ?? self.hermo, + hieroglyphist: hieroglyphist ?? self.hieroglyphist, + homocerc: homocerc ?? self.homocerc, + icteroid: icteroid ?? self.icteroid, + immortal: immortal ?? self.immortal, + impetulant: impetulant ?? self.impetulant, + irrigate: irrigate ?? self.irrigate, + myxedema: myxedema ?? self.myxedema, + nonbookish: nonbookish ?? self.nonbookish, + onyx: onyx ?? self.onyx, + repasser: repasser ?? self.repasser, + septomarginal: septomarginal ?? self.septomarginal, + subdie: subdie ?? self.subdie, + tibiometatarsal: tibiometatarsal ?? self.tibiometatarsal, + waltzlike: waltzlike ?? self.waltzlike + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - Ressaut +struct Ressaut: Codable, Hashable { + let apperceptive: String + let cuttoo: String + let douser: String + let drinkproof: String + let forementioned: String + let freesia: String + let genevieve: String + let hyperdiabolical: String + let hypocone: String + let irreverentially: String + let jumart: String + let mimosaceae: String + let mollicrush: String + let nedder: String + let retinasphalt: String + let sough: String + let steading: String + let theopaschitism: String + let undurableness: String + let unmingleable: String + + enum CodingKeys: String, CodingKey { + case apperceptive = "apperceptive" + case cuttoo = "cuttoo" + case douser = "douser" + case drinkproof = "drinkproof" + case forementioned = "forementioned" + case freesia = "Freesia" + case genevieve = "Genevieve" + case hyperdiabolical = "hyperdiabolical" + case hypocone = "hypocone" + case irreverentially = "irreverentially" + case jumart = "jumart" + case mimosaceae = "Mimosaceae" + case mollicrush = "mollicrush" + case nedder = "nedder" + case retinasphalt = "retinasphalt" + case sough = "sough" + case steading = "steading" + case theopaschitism = "Theopaschitism" + case undurableness = "undurableness" + case unmingleable = "unmingleable" + } +} + +// MARK: Ressaut convenience initializers and mutators + +extension Ressaut { + init(data: Data) throws { + self = try newJSONDecoder().decode(Ressaut.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + apperceptive: String? = nil, + cuttoo: String? = nil, + douser: String? = nil, + drinkproof: String? = nil, + forementioned: String? = nil, + freesia: String? = nil, + genevieve: String? = nil, + hyperdiabolical: String? = nil, + hypocone: String? = nil, + irreverentially: String? = nil, + jumart: String? = nil, + mimosaceae: String? = nil, + mollicrush: String? = nil, + nedder: String? = nil, + retinasphalt: String? = nil, + sough: String? = nil, + steading: String? = nil, + theopaschitism: String? = nil, + undurableness: String? = nil, + unmingleable: String? = nil + ) -> Ressaut { + return Ressaut( + apperceptive: apperceptive ?? self.apperceptive, + cuttoo: cuttoo ?? self.cuttoo, + douser: douser ?? self.douser, + drinkproof: drinkproof ?? self.drinkproof, + forementioned: forementioned ?? self.forementioned, + freesia: freesia ?? self.freesia, + genevieve: genevieve ?? self.genevieve, + hyperdiabolical: hyperdiabolical ?? self.hyperdiabolical, + hypocone: hypocone ?? self.hypocone, + irreverentially: irreverentially ?? self.irreverentially, + jumart: jumart ?? self.jumart, + mimosaceae: mimosaceae ?? self.mimosaceae, + mollicrush: mollicrush ?? self.mollicrush, + nedder: nedder ?? self.nedder, + retinasphalt: retinasphalt ?? self.retinasphalt, + sough: sough ?? self.sough, + steading: steading ?? self.steading, + theopaschitism: theopaschitism ?? self.theopaschitism, + undurableness: undurableness ?? self.undurableness, + unmingleable: unmingleable ?? self.unmingleable + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Retrocervical: Codable, Hashable { + case integer(Int) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + throw DecodingError.typeMismatch(Retrocervical.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Retrocervical")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +enum Revert: Codable, Hashable { + case bool(Bool) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Revert.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Revert")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum RewriteElement: Codable, Hashable { + case double(Double) + case nullArray([JSONNull?]) + case rewriteClass(RewriteClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(RewriteClass.self) { + self = .rewriteClass(x) + return + } + throw DecodingError.typeMismatch(RewriteElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for RewriteElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .rewriteClass(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - RewriteClass +struct RewriteClass: Codable, Hashable { + let accountancy: JSONNull? + let cacotrophic: JSONNull? + let contest: JSONNull? + let couthily: JSONNull? + let falculate: JSONNull? + let foreseize: JSONNull? + let hyades: JSONNull? + let lemnad: JSONNull? + let monotheistically: JSONNull? + let nonflying: JSONNull? + let ptenoglossa: JSONNull? + let repatch: JSONNull? + let rodman: JSONNull? + let strung: JSONNull? + let titmal: JSONNull? + let twalpennyworth: JSONNull? + let unblamable: JSONNull? + let vertical: JSONNull? + let whiggification: JSONNull? + let yardman: JSONNull? + + enum CodingKeys: String, CodingKey { + case accountancy = "accountancy" + case cacotrophic = "cacotrophic" + case contest = "contest" + case couthily = "couthily" + case falculate = "falculate" + case foreseize = "foreseize" + case hyades = "Hyades" + case lemnad = "lemnad" + case monotheistically = "monotheistically" + case nonflying = "nonflying" + case ptenoglossa = "Ptenoglossa" + case repatch = "repatch" + case rodman = "rodman" + case strung = "strung" + case titmal = "titmal" + case twalpennyworth = "twalpennyworth" + case unblamable = "unblamable" + case vertical = "vertical" + case whiggification = "Whiggification" + case yardman = "yardman" + } +} + +// MARK: RewriteClass convenience initializers and mutators + +extension RewriteClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(RewriteClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + accountancy: JSONNull?? = nil, + cacotrophic: JSONNull?? = nil, + contest: JSONNull?? = nil, + couthily: JSONNull?? = nil, + falculate: JSONNull?? = nil, + foreseize: JSONNull?? = nil, + hyades: JSONNull?? = nil, + lemnad: JSONNull?? = nil, + monotheistically: JSONNull?? = nil, + nonflying: JSONNull?? = nil, + ptenoglossa: JSONNull?? = nil, + repatch: JSONNull?? = nil, + rodman: JSONNull?? = nil, + strung: JSONNull?? = nil, + titmal: JSONNull?? = nil, + twalpennyworth: JSONNull?? = nil, + unblamable: JSONNull?? = nil, + vertical: JSONNull?? = nil, + whiggification: JSONNull?? = nil, + yardman: JSONNull?? = nil + ) -> RewriteClass { + return RewriteClass( + accountancy: accountancy ?? self.accountancy, + cacotrophic: cacotrophic ?? self.cacotrophic, + contest: contest ?? self.contest, + couthily: couthily ?? self.couthily, + falculate: falculate ?? self.falculate, + foreseize: foreseize ?? self.foreseize, + hyades: hyades ?? self.hyades, + lemnad: lemnad ?? self.lemnad, + monotheistically: monotheistically ?? self.monotheistically, + nonflying: nonflying ?? self.nonflying, + ptenoglossa: ptenoglossa ?? self.ptenoglossa, + repatch: repatch ?? self.repatch, + rodman: rodman ?? self.rodman, + strung: strung ?? self.strung, + titmal: titmal ?? self.titmal, + twalpennyworth: twalpennyworth ?? self.twalpennyworth, + unblamable: unblamable ?? self.unblamable, + vertical: vertical ?? self.vertical, + whiggification: whiggification ?? self.whiggification, + yardman: yardman ?? self.yardman + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Saccoderm: Codable, Hashable { + case integerArray([Int]) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Saccoderm.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Saccoderm")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum SantirElement: Codable, Hashable { + case double(Double) + case santirClass(SantirClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(SantirClass.self) { + self = .santirClass(x) + return + } + throw DecodingError.typeMismatch(SantirElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for SantirElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .santirClass(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - SantirClass +struct SantirClass: Codable, Hashable { + let admiredly: JSONNull? + let demicaponier: JSONNull? + let epitympanic: JSONNull? + let investitor: JSONNull? + let lupiform: JSONNull? + let monoflagellate: JSONNull? + let paleoethnic: JSONNull? + let prediscountable: JSONNull? + let rhetoricals: JSONNull? + let roomth: JSONNull? + let saccharose: JSONNull? + let septonasal: JSONNull? + let serpenticide: JSONNull? + let setarious: JSONNull? + let spaework: JSONNull? + let stylite: JSONNull? + let suessiones: JSONNull? + let timelily: JSONNull? + let unprofaned: JSONNull? + let vorticular: JSONNull? + + enum CodingKeys: String, CodingKey { + case admiredly = "admiredly" + case demicaponier = "demicaponier" + case epitympanic = "epitympanic" + case investitor = "investitor" + case lupiform = "lupiform" + case monoflagellate = "monoflagellate" + case paleoethnic = "paleoethnic" + case prediscountable = "prediscountable" + case rhetoricals = "rhetoricals" + case roomth = "roomth" + case saccharose = "saccharose" + case septonasal = "septonasal" + case serpenticide = "serpenticide" + case setarious = "setarious" + case spaework = "spaework" + case stylite = "stylite" + case suessiones = "Suessiones" + case timelily = "timelily" + case unprofaned = "unprofaned" + case vorticular = "vorticular" + } +} + +// MARK: SantirClass convenience initializers and mutators + +extension SantirClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(SantirClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + admiredly: JSONNull?? = nil, + demicaponier: JSONNull?? = nil, + epitympanic: JSONNull?? = nil, + investitor: JSONNull?? = nil, + lupiform: JSONNull?? = nil, + monoflagellate: JSONNull?? = nil, + paleoethnic: JSONNull?? = nil, + prediscountable: JSONNull?? = nil, + rhetoricals: JSONNull?? = nil, + roomth: JSONNull?? = nil, + saccharose: JSONNull?? = nil, + septonasal: JSONNull?? = nil, + serpenticide: JSONNull?? = nil, + setarious: JSONNull?? = nil, + spaework: JSONNull?? = nil, + stylite: JSONNull?? = nil, + suessiones: JSONNull?? = nil, + timelily: JSONNull?? = nil, + unprofaned: JSONNull?? = nil, + vorticular: JSONNull?? = nil + ) -> SantirClass { + return SantirClass( + admiredly: admiredly ?? self.admiredly, + demicaponier: demicaponier ?? self.demicaponier, + epitympanic: epitympanic ?? self.epitympanic, + investitor: investitor ?? self.investitor, + lupiform: lupiform ?? self.lupiform, + monoflagellate: monoflagellate ?? self.monoflagellate, + paleoethnic: paleoethnic ?? self.paleoethnic, + prediscountable: prediscountable ?? self.prediscountable, + rhetoricals: rhetoricals ?? self.rhetoricals, + roomth: roomth ?? self.roomth, + saccharose: saccharose ?? self.saccharose, + septonasal: septonasal ?? self.septonasal, + serpenticide: serpenticide ?? self.serpenticide, + setarious: setarious ?? self.setarious, + spaework: spaework ?? self.spaework, + stylite: stylite ?? self.stylite, + suessiones: suessiones ?? self.suessiones, + timelily: timelily ?? self.timelily, + unprofaned: unprofaned ?? self.unprofaned, + vorticular: vorticular ?? self.vorticular + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Saprophilous: Codable, Hashable { + case integerMap([String: Int]) + case string(String) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Saprophilous.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Saprophilous")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum SaxtenElement: Codable, Hashable { + case saxtenClass(SaxtenClass) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(SaxtenClass.self) { + self = .saxtenClass(x) + return + } + throw DecodingError.typeMismatch(SaxtenElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for SaxtenElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .saxtenClass(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - SaxtenClass +struct SaxtenClass: Codable, Hashable { + let algarrobilla: JSONNull? + let bowgrace: JSONNull? + let catharticalness: Double? + let centaurid: JSONNull? + let chirotherium: Int? + let disdiapason: String? + let flix: JSONNull? + let germanely: JSONNull? + let homocerc: Bool? + let inhume: JSONNull? + let lepidote: JSONNull? + let megalochirous: JSONNull? + let ninepenny: JSONNull? + let nonbookish: JSONNull? + let nondeist: JSONNull? + let nymphaeaceous: JSONNull? + let parietofrontal: JSONNull? + let sancyite: JSONNull? + let subjectivist: JSONNull? + let tibiad: JSONNull? + let transonic: JSONNull? + let tripetalous: JSONNull? + let trunchman: JSONNull? + let urger: JSONNull? + let withdrawnness: JSONNull? + + enum CodingKeys: String, CodingKey { + case algarrobilla = "algarrobilla" + case bowgrace = "bowgrace" + case catharticalness = "catharticalness" + case centaurid = "Centaurid" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case flix = "flix" + case germanely = "germanely" + case homocerc = "homocerc" + case inhume = "inhume" + case lepidote = "lepidote" + case megalochirous = "megalochirous" + case ninepenny = "ninepenny" + case nonbookish = "nonbookish" + case nondeist = "nondeist" + case nymphaeaceous = "nymphaeaceous" + case parietofrontal = "parietofrontal" + case sancyite = "sancyite" + case subjectivist = "subjectivist" + case tibiad = "tibiad" + case transonic = "transonic" + case tripetalous = "tripetalous" + case trunchman = "trunchman" + case urger = "urger" + case withdrawnness = "withdrawnness" + } +} + +// MARK: SaxtenClass convenience initializers and mutators + +extension SaxtenClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(SaxtenClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + algarrobilla: JSONNull?? = nil, + bowgrace: JSONNull?? = nil, + catharticalness: Double?? = nil, + centaurid: JSONNull?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + flix: JSONNull?? = nil, + germanely: JSONNull?? = nil, + homocerc: Bool?? = nil, + inhume: JSONNull?? = nil, + lepidote: JSONNull?? = nil, + megalochirous: JSONNull?? = nil, + ninepenny: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + nondeist: JSONNull?? = nil, + nymphaeaceous: JSONNull?? = nil, + parietofrontal: JSONNull?? = nil, + sancyite: JSONNull?? = nil, + subjectivist: JSONNull?? = nil, + tibiad: JSONNull?? = nil, + transonic: JSONNull?? = nil, + tripetalous: JSONNull?? = nil, + trunchman: JSONNull?? = nil, + urger: JSONNull?? = nil, + withdrawnness: JSONNull?? = nil + ) -> SaxtenClass { + return SaxtenClass( + algarrobilla: algarrobilla ?? self.algarrobilla, + bowgrace: bowgrace ?? self.bowgrace, + catharticalness: catharticalness ?? self.catharticalness, + centaurid: centaurid ?? self.centaurid, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + flix: flix ?? self.flix, + germanely: germanely ?? self.germanely, + homocerc: homocerc ?? self.homocerc, + inhume: inhume ?? self.inhume, + lepidote: lepidote ?? self.lepidote, + megalochirous: megalochirous ?? self.megalochirous, + ninepenny: ninepenny ?? self.ninepenny, + nonbookish: nonbookish ?? self.nonbookish, + nondeist: nondeist ?? self.nondeist, + nymphaeaceous: nymphaeaceous ?? self.nymphaeaceous, + parietofrontal: parietofrontal ?? self.parietofrontal, + sancyite: sancyite ?? self.sancyite, + subjectivist: subjectivist ?? self.subjectivist, + tibiad: tibiad ?? self.tibiad, + transonic: transonic ?? self.transonic, + tripetalous: tripetalous ?? self.tripetalous, + trunchman: trunchman ?? self.trunchman, + urger: urger ?? self.urger, + withdrawnness: withdrawnness ?? self.withdrawnness + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - Scatty +struct Scatty: Codable, Hashable { + let aeriferous: JSONNull? + let antical: JSONNull? + let antighostism: JSONNull? + let arcanum: JSONNull? + let autotrophy: JSONNull? + let baronial: JSONNull? + let caffeine: JSONNull? + let gorgoniacean: JSONNull? + let heroical: JSONNull? + let hydropical: JSONNull? + let mechanology: JSONNull? + let musicopoetic: JSONNull? + let officiality: JSONNull? + let oftentimes: JSONNull? + let ophthalmotonometer: JSONNull? + let reflectively: JSONNull? + let springer: JSONNull? + let tabasco: JSONNull? + let teleianthous: JSONNull? + let uncombated: JSONNull? + + enum CodingKeys: String, CodingKey { + case aeriferous = "aeriferous" + case antical = "antical" + case antighostism = "antighostism" + case arcanum = "arcanum" + case autotrophy = "autotrophy" + case baronial = "baronial" + case caffeine = "caffeine" + case gorgoniacean = "gorgoniacean" + case heroical = "heroical" + case hydropical = "hydropical" + case mechanology = "mechanology" + case musicopoetic = "musicopoetic" + case officiality = "officiality" + case oftentimes = "oftentimes" + case ophthalmotonometer = "ophthalmotonometer" + case reflectively = "reflectively" + case springer = "springer" + case tabasco = "Tabasco" + case teleianthous = "teleianthous" + case uncombated = "uncombated" + } +} + +// MARK: Scatty convenience initializers and mutators + +extension Scatty { + init(data: Data) throws { + self = try newJSONDecoder().decode(Scatty.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + aeriferous: JSONNull?? = nil, + antical: JSONNull?? = nil, + antighostism: JSONNull?? = nil, + arcanum: JSONNull?? = nil, + autotrophy: JSONNull?? = nil, + baronial: JSONNull?? = nil, + caffeine: JSONNull?? = nil, + gorgoniacean: JSONNull?? = nil, + heroical: JSONNull?? = nil, + hydropical: JSONNull?? = nil, + mechanology: JSONNull?? = nil, + musicopoetic: JSONNull?? = nil, + officiality: JSONNull?? = nil, + oftentimes: JSONNull?? = nil, + ophthalmotonometer: JSONNull?? = nil, + reflectively: JSONNull?? = nil, + springer: JSONNull?? = nil, + tabasco: JSONNull?? = nil, + teleianthous: JSONNull?? = nil, + uncombated: JSONNull?? = nil + ) -> Scatty { + return Scatty( + aeriferous: aeriferous ?? self.aeriferous, + antical: antical ?? self.antical, + antighostism: antighostism ?? self.antighostism, + arcanum: arcanum ?? self.arcanum, + autotrophy: autotrophy ?? self.autotrophy, + baronial: baronial ?? self.baronial, + caffeine: caffeine ?? self.caffeine, + gorgoniacean: gorgoniacean ?? self.gorgoniacean, + heroical: heroical ?? self.heroical, + hydropical: hydropical ?? self.hydropical, + mechanology: mechanology ?? self.mechanology, + musicopoetic: musicopoetic ?? self.musicopoetic, + officiality: officiality ?? self.officiality, + oftentimes: oftentimes ?? self.oftentimes, + ophthalmotonometer: ophthalmotonometer ?? self.ophthalmotonometer, + reflectively: reflectively ?? self.reflectively, + springer: springer ?? self.springer, + tabasco: tabasco ?? self.tabasco, + teleianthous: teleianthous ?? self.teleianthous, + uncombated: uncombated ?? self.uncombated + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Scoffer: Codable, Hashable { + case integerMap([String: Int]) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Scoffer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Scoffer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Scrampum: Codable, Hashable { + case bool(Bool) + case integerArray([Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Scrampum.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Scrampum")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Serpentinic: Codable, Hashable { + case double(Double) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Serpentinic.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Serpentinic")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +enum Shadowable: Codable, Hashable { + case bool(Bool) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + throw DecodingError.typeMismatch(Shadowable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Shadowable")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +enum SisteringElement: Codable, Hashable { + case integer(Int) + case nullArray([JSONNull?]) + case sisteringClass(SisteringClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(SisteringClass.self) { + self = .sisteringClass(x) + return + } + throw DecodingError.typeMismatch(SisteringElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for SisteringElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .sisteringClass(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - SisteringClass +struct SisteringClass: Codable, Hashable { + let amphicarpic: JSONNull? + let chianti: JSONNull? + let frigorific: JSONNull? + let haplomi: JSONNull? + let hyperkinesis: JSONNull? + let laudable: JSONNull? + let madwoman: JSONNull? + let maimedly: JSONNull? + let micropterygidae: JSONNull? + let microrhabdus: JSONNull? + let nondense: JSONNull? + let phlebemphraxis: JSONNull? + let redsear: JSONNull? + let schismatical: JSONNull? + let tartryl: JSONNull? + let unabhorred: JSONNull? + let undeliberateness: JSONNull? + let unmixable: JSONNull? + let untruckling: JSONNull? + let vineal: JSONNull? + + enum CodingKeys: String, CodingKey { + case amphicarpic = "amphicarpic" + case chianti = "Chianti" + case frigorific = "frigorific" + case haplomi = "Haplomi" + case hyperkinesis = "hyperkinesis" + case laudable = "laudable" + case madwoman = "madwoman" + case maimedly = "maimedly" + case micropterygidae = "Micropterygidae" + case microrhabdus = "microrhabdus" + case nondense = "nondense" + case phlebemphraxis = "phlebemphraxis" + case redsear = "redsear" + case schismatical = "schismatical" + case tartryl = "tartryl" + case unabhorred = "unabhorred" + case undeliberateness = "undeliberateness" + case unmixable = "unmixable" + case untruckling = "untruckling" + case vineal = "vineal" + } +} + +// MARK: SisteringClass convenience initializers and mutators + +extension SisteringClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(SisteringClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + amphicarpic: JSONNull?? = nil, + chianti: JSONNull?? = nil, + frigorific: JSONNull?? = nil, + haplomi: JSONNull?? = nil, + hyperkinesis: JSONNull?? = nil, + laudable: JSONNull?? = nil, + madwoman: JSONNull?? = nil, + maimedly: JSONNull?? = nil, + micropterygidae: JSONNull?? = nil, + microrhabdus: JSONNull?? = nil, + nondense: JSONNull?? = nil, + phlebemphraxis: JSONNull?? = nil, + redsear: JSONNull?? = nil, + schismatical: JSONNull?? = nil, + tartryl: JSONNull?? = nil, + unabhorred: JSONNull?? = nil, + undeliberateness: JSONNull?? = nil, + unmixable: JSONNull?? = nil, + untruckling: JSONNull?? = nil, + vineal: JSONNull?? = nil + ) -> SisteringClass { + return SisteringClass( + amphicarpic: amphicarpic ?? self.amphicarpic, + chianti: chianti ?? self.chianti, + frigorific: frigorific ?? self.frigorific, + haplomi: haplomi ?? self.haplomi, + hyperkinesis: hyperkinesis ?? self.hyperkinesis, + laudable: laudable ?? self.laudable, + madwoman: madwoman ?? self.madwoman, + maimedly: maimedly ?? self.maimedly, + micropterygidae: micropterygidae ?? self.micropterygidae, + microrhabdus: microrhabdus ?? self.microrhabdus, + nondense: nondense ?? self.nondense, + phlebemphraxis: phlebemphraxis ?? self.phlebemphraxis, + redsear: redsear ?? self.redsear, + schismatical: schismatical ?? self.schismatical, + tartryl: tartryl ?? self.tartryl, + unabhorred: unabhorred ?? self.unabhorred, + undeliberateness: undeliberateness ?? self.undeliberateness, + unmixable: unmixable ?? self.unmixable, + untruckling: untruckling ?? self.untruckling, + vineal: vineal ?? self.vineal + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - Staghunting +struct Staghunting: Codable, Hashable { + let calorimetric: Int? + let canid: Int? + let catharticalness: Double? + let chirotherium: Int? + let disdiapason: String? + let ditriglyphic: Int? + let floriferousness: Int? + let gamelike: Int? + let grig: Int? + let homocerc: Bool? + let interloan: Int? + let lithotomy: Int? + let loric: Int? + let membranocoriaceous: Int? + let membranogenic: Int? + let nonbookish: JSONNull? + let overtrump: Int? + let scotino: Int? + let seasonable: Int? + let sephen: Int? + let stigmarioid: Int? + let tired: Int? + let trifid: Int? + let undefeatedly: Int? + let ungirlish: Int? + + enum CodingKeys: String, CodingKey { + case calorimetric = "calorimetric" + case canid = "canid" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case disdiapason = "disdiapason" + case ditriglyphic = "ditriglyphic" + case floriferousness = "floriferousness" + case gamelike = "gamelike" + case grig = "grig" + case homocerc = "homocerc" + case interloan = "interloan" + case lithotomy = "lithotomy" + case loric = "loric" + case membranocoriaceous = "membranocoriaceous" + case membranogenic = "membranogenic" + case nonbookish = "nonbookish" + case overtrump = "overtrump" + case scotino = "scotino" + case seasonable = "seasonable" + case sephen = "sephen" + case stigmarioid = "stigmarioid" + case tired = "tired" + case trifid = "trifid" + case undefeatedly = "undefeatedly" + case ungirlish = "ungirlish" + } +} + +// MARK: Staghunting convenience initializers and mutators + +extension Staghunting { + init(data: Data) throws { + self = try newJSONDecoder().decode(Staghunting.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + calorimetric: Int?? = nil, + canid: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + disdiapason: String?? = nil, + ditriglyphic: Int?? = nil, + floriferousness: Int?? = nil, + gamelike: Int?? = nil, + grig: Int?? = nil, + homocerc: Bool?? = nil, + interloan: Int?? = nil, + lithotomy: Int?? = nil, + loric: Int?? = nil, + membranocoriaceous: Int?? = nil, + membranogenic: Int?? = nil, + nonbookish: JSONNull?? = nil, + overtrump: Int?? = nil, + scotino: Int?? = nil, + seasonable: Int?? = nil, + sephen: Int?? = nil, + stigmarioid: Int?? = nil, + tired: Int?? = nil, + trifid: Int?? = nil, + undefeatedly: Int?? = nil, + ungirlish: Int?? = nil + ) -> Staghunting { + return Staghunting( + calorimetric: calorimetric ?? self.calorimetric, + canid: canid ?? self.canid, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + disdiapason: disdiapason ?? self.disdiapason, + ditriglyphic: ditriglyphic ?? self.ditriglyphic, + floriferousness: floriferousness ?? self.floriferousness, + gamelike: gamelike ?? self.gamelike, + grig: grig ?? self.grig, + homocerc: homocerc ?? self.homocerc, + interloan: interloan ?? self.interloan, + lithotomy: lithotomy ?? self.lithotomy, + loric: loric ?? self.loric, + membranocoriaceous: membranocoriaceous ?? self.membranocoriaceous, + membranogenic: membranogenic ?? self.membranogenic, + nonbookish: nonbookish ?? self.nonbookish, + overtrump: overtrump ?? self.overtrump, + scotino: scotino ?? self.scotino, + seasonable: seasonable ?? self.seasonable, + sephen: sephen ?? self.sephen, + stigmarioid: stigmarioid ?? self.stigmarioid, + tired: tired ?? self.tired, + trifid: trifid ?? self.trifid, + undefeatedly: undefeatedly ?? self.undefeatedly, + ungirlish: ungirlish ?? self.ungirlish + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Stagmometer: Codable, Hashable { + case string(String) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Stagmometer.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Stagmometer")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .string(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +enum Stimulability: Codable, Hashable { + case bool(Bool) + case integer(Int) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Stimulability.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Stimulability")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Strangleable: Codable, Hashable { + case double(Double) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Strangleable.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Strangleable")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum StrenuosityElement: Codable, Hashable { + case nullArray([JSONNull?]) + case strenuosityClass(StrenuosityClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(StrenuosityClass.self) { + self = .strenuosityClass(x) + return + } + throw DecodingError.typeMismatch(StrenuosityElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for StrenuosityElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .strenuosityClass(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - StrenuosityClass +struct StrenuosityClass: Codable, Hashable { + let bliss: Int? + let buccate: Int? + let bulletproof: Int? + let catharticalness: Double? + let chirotherium: Int? + let crumblingness: Int? + let disdiapason: String? + let engagedly: Int? + let fightable: Int? + let hoariness: Int? + let homocerc: Bool? + let hypopodium: Int? + let luxurist: Int? + let mechanician: Int? + let nonbookish: JSONNull? + let onopordon: Int? + let podgily: Int? + let reformableness: Int? + let scatterbrains: Int? + let seminuria: Int? + let sodomite: Int? + let tramp: Int? + let undueness: Int? + let worthily: Int? + let yankeeist: Int? + + enum CodingKeys: String, CodingKey { + case bliss = "bliss" + case buccate = "buccate" + case bulletproof = "bulletproof" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case crumblingness = "crumblingness" + case disdiapason = "disdiapason" + case engagedly = "engagedly" + case fightable = "fightable" + case hoariness = "hoariness" + case homocerc = "homocerc" + case hypopodium = "hypopodium" + case luxurist = "luxurist" + case mechanician = "mechanician" + case nonbookish = "nonbookish" + case onopordon = "Onopordon" + case podgily = "podgily" + case reformableness = "reformableness" + case scatterbrains = "scatterbrains" + case seminuria = "seminuria" + case sodomite = "Sodomite" + case tramp = "tramp" + case undueness = "undueness" + case worthily = "worthily" + case yankeeist = "Yankeeist" + } +} + +// MARK: StrenuosityClass convenience initializers and mutators + +extension StrenuosityClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(StrenuosityClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + bliss: Int?? = nil, + buccate: Int?? = nil, + bulletproof: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + crumblingness: Int?? = nil, + disdiapason: String?? = nil, + engagedly: Int?? = nil, + fightable: Int?? = nil, + hoariness: Int?? = nil, + homocerc: Bool?? = nil, + hypopodium: Int?? = nil, + luxurist: Int?? = nil, + mechanician: Int?? = nil, + nonbookish: JSONNull?? = nil, + onopordon: Int?? = nil, + podgily: Int?? = nil, + reformableness: Int?? = nil, + scatterbrains: Int?? = nil, + seminuria: Int?? = nil, + sodomite: Int?? = nil, + tramp: Int?? = nil, + undueness: Int?? = nil, + worthily: Int?? = nil, + yankeeist: Int?? = nil + ) -> StrenuosityClass { + return StrenuosityClass( + bliss: bliss ?? self.bliss, + buccate: buccate ?? self.buccate, + bulletproof: bulletproof ?? self.bulletproof, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + crumblingness: crumblingness ?? self.crumblingness, + disdiapason: disdiapason ?? self.disdiapason, + engagedly: engagedly ?? self.engagedly, + fightable: fightable ?? self.fightable, + hoariness: hoariness ?? self.hoariness, + homocerc: homocerc ?? self.homocerc, + hypopodium: hypopodium ?? self.hypopodium, + luxurist: luxurist ?? self.luxurist, + mechanician: mechanician ?? self.mechanician, + nonbookish: nonbookish ?? self.nonbookish, + onopordon: onopordon ?? self.onopordon, + podgily: podgily ?? self.podgily, + reformableness: reformableness ?? self.reformableness, + scatterbrains: scatterbrains ?? self.scatterbrains, + seminuria: seminuria ?? self.seminuria, + sodomite: sodomite ?? self.sodomite, + tramp: tramp ?? self.tramp, + undueness: undueness ?? self.undueness, + worthily: worthily ?? self.worthily, + yankeeist: yankeeist ?? self.yankeeist + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Tabaxir: Codable, Hashable { + case bool(Bool) + case double(Double) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + throw DecodingError.typeMismatch(Tabaxir.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Tabaxir")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + } + } +} + +enum Talpiform: Codable, Hashable { + case double(Double) + case quebrachineClass(QuebrachineClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Talpiform.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Talpiform")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Thwack: Codable, Hashable { + case bool(Bool) + case double(Double) + case quebrachineClass(QuebrachineClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + throw DecodingError.typeMismatch(Thwack.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Thwack")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + } + } +} + +enum Tortricine: Codable, Hashable { + case quebrachineClass(QuebrachineClass) + case unionArray([Int?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int?].self) { + self = .unionArray(x) + return + } + if let x = try? container.decode(QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + throw DecodingError.typeMismatch(Tortricine.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Tortricine")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .quebrachineClass(let x): + try container.encode(x) + case .unionArray(let x): + try container.encode(x) + } + } +} + +enum TruantcyElement: Codable, Hashable { + case bool(Bool) + case truantcyClass(TruantcyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(TruantcyClass.self) { + self = .truantcyClass(x) + return + } + throw DecodingError.typeMismatch(TruantcyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for TruantcyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .truantcyClass(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - TruantcyClass +struct TruantcyClass: Codable, Hashable { + let alfiona: JSONNull? + let ascaridiasis: JSONNull? + let bungey: JSONNull? + let catharticalness: Double? + let ceroxyle: JSONNull? + let chirotherium: Int? + let chorology: JSONNull? + let disdiapason: String? + let enmarble: JSONNull? + let epeira: JSONNull? + let eurylaimi: JSONNull? + let germination: JSONNull? + let hallelujah: JSONNull? + let homocerc: Bool? + let lev: JSONNull? + let mouthing: JSONNull? + let nonbookish: JSONNull? + let philliloo: JSONNull? + let planetal: JSONNull? + let poney: JSONNull? + let punctualist: JSONNull? + let returnlessly: JSONNull? + let skelder: JSONNull? + let windwaywardly: JSONNull? + let yuman: JSONNull? + + enum CodingKeys: String, CodingKey { + case alfiona = "alfiona" + case ascaridiasis = "ascaridiasis" + case bungey = "bungey" + case catharticalness = "catharticalness" + case ceroxyle = "ceroxyle" + case chirotherium = "Chirotherium" + case chorology = "chorology" + case disdiapason = "disdiapason" + case enmarble = "enmarble" + case epeira = "Epeira" + case eurylaimi = "Eurylaimi" + case germination = "germination" + case hallelujah = "hallelujah" + case homocerc = "homocerc" + case lev = "lev" + case mouthing = "mouthing" + case nonbookish = "nonbookish" + case philliloo = "philliloo" + case planetal = "planetal" + case poney = "poney" + case punctualist = "punctualist" + case returnlessly = "returnlessly" + case skelder = "skelder" + case windwaywardly = "windwaywardly" + case yuman = "Yuman" + } +} + +// MARK: TruantcyClass convenience initializers and mutators + +extension TruantcyClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(TruantcyClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + alfiona: JSONNull?? = nil, + ascaridiasis: JSONNull?? = nil, + bungey: JSONNull?? = nil, + catharticalness: Double?? = nil, + ceroxyle: JSONNull?? = nil, + chirotherium: Int?? = nil, + chorology: JSONNull?? = nil, + disdiapason: String?? = nil, + enmarble: JSONNull?? = nil, + epeira: JSONNull?? = nil, + eurylaimi: JSONNull?? = nil, + germination: JSONNull?? = nil, + hallelujah: JSONNull?? = nil, + homocerc: Bool?? = nil, + lev: JSONNull?? = nil, + mouthing: JSONNull?? = nil, + nonbookish: JSONNull?? = nil, + philliloo: JSONNull?? = nil, + planetal: JSONNull?? = nil, + poney: JSONNull?? = nil, + punctualist: JSONNull?? = nil, + returnlessly: JSONNull?? = nil, + skelder: JSONNull?? = nil, + windwaywardly: JSONNull?? = nil, + yuman: JSONNull?? = nil + ) -> TruantcyClass { + return TruantcyClass( + alfiona: alfiona ?? self.alfiona, + ascaridiasis: ascaridiasis ?? self.ascaridiasis, + bungey: bungey ?? self.bungey, + catharticalness: catharticalness ?? self.catharticalness, + ceroxyle: ceroxyle ?? self.ceroxyle, + chirotherium: chirotherium ?? self.chirotherium, + chorology: chorology ?? self.chorology, + disdiapason: disdiapason ?? self.disdiapason, + enmarble: enmarble ?? self.enmarble, + epeira: epeira ?? self.epeira, + eurylaimi: eurylaimi ?? self.eurylaimi, + germination: germination ?? self.germination, + hallelujah: hallelujah ?? self.hallelujah, + homocerc: homocerc ?? self.homocerc, + lev: lev ?? self.lev, + mouthing: mouthing ?? self.mouthing, + nonbookish: nonbookish ?? self.nonbookish, + philliloo: philliloo ?? self.philliloo, + planetal: planetal ?? self.planetal, + poney: poney ?? self.poney, + punctualist: punctualist ?? self.punctualist, + returnlessly: returnlessly ?? self.returnlessly, + skelder: skelder ?? self.skelder, + windwaywardly: windwaywardly ?? self.windwaywardly, + yuman: yuman ?? self.yuman + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Unbeginning: Codable, Hashable { + case integerMap([String: Int]) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Unbeginning.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unbeginning")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Undesirability: Codable, Hashable { + case integerArray([Int]) + case integerMap([String: Int]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Undesirability.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Undesirability")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integerArray(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Unerasing: Codable, Hashable { + case integer(Int) + case integerMap([String: Int]) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Unerasing.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unerasing")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Unguentarium: Codable, Hashable { + case integer(Int) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Unguentarium.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unguentarium")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum UnimpeachablyElement: Codable, Hashable { + case bool(Bool) + case unimpeachablyClass(UnimpeachablyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(UnimpeachablyClass.self) { + self = .unimpeachablyClass(x) + return + } + throw DecodingError.typeMismatch(UnimpeachablyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for UnimpeachablyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .unimpeachablyClass(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - UnimpeachablyClass +struct UnimpeachablyClass: Codable, Hashable { + let acerin: Int? + let bobadil: Int? + let catharticalness: Double? + let chirotherium: Int? + let chlorophylligenous: Int? + let conversational: Int? + let demiowl: Int? + let disdiapason: String? + let ectorhinal: Int? + let gamblesomeness: Int? + let homocerc: Bool? + let irrorate: Int? + let kindergartening: Int? + let lateritic: Int? + let mespil: Int? + let misconfiguration: Int? + let nonbookish: JSONNull? + let planometry: Int? + let quiina: Int? + let robert: Int? + let rot: Int? + let subcinctorium: Int? + let tussocker: Int? + let ultraproud: Int? + let unsuggestedness: Int? + + enum CodingKeys: String, CodingKey { + case acerin = "acerin" + case bobadil = "Bobadil" + case catharticalness = "catharticalness" + case chirotherium = "Chirotherium" + case chlorophylligenous = "chlorophylligenous" + case conversational = "conversational" + case demiowl = "demiowl" + case disdiapason = "disdiapason" + case ectorhinal = "ectorhinal" + case gamblesomeness = "gamblesomeness" + case homocerc = "homocerc" + case irrorate = "irrorate" + case kindergartening = "kindergartening" + case lateritic = "lateritic" + case mespil = "mespil" + case misconfiguration = "misconfiguration" + case nonbookish = "nonbookish" + case planometry = "planometry" + case quiina = "Quiina" + case robert = "Robert" + case rot = "rot" + case subcinctorium = "subcinctorium" + case tussocker = "tussocker" + case ultraproud = "ultraproud" + case unsuggestedness = "unsuggestedness" + } +} + +// MARK: UnimpeachablyClass convenience initializers and mutators + +extension UnimpeachablyClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(UnimpeachablyClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + acerin: Int?? = nil, + bobadil: Int?? = nil, + catharticalness: Double?? = nil, + chirotherium: Int?? = nil, + chlorophylligenous: Int?? = nil, + conversational: Int?? = nil, + demiowl: Int?? = nil, + disdiapason: String?? = nil, + ectorhinal: Int?? = nil, + gamblesomeness: Int?? = nil, + homocerc: Bool?? = nil, + irrorate: Int?? = nil, + kindergartening: Int?? = nil, + lateritic: Int?? = nil, + mespil: Int?? = nil, + misconfiguration: Int?? = nil, + nonbookish: JSONNull?? = nil, + planometry: Int?? = nil, + quiina: Int?? = nil, + robert: Int?? = nil, + rot: Int?? = nil, + subcinctorium: Int?? = nil, + tussocker: Int?? = nil, + ultraproud: Int?? = nil, + unsuggestedness: Int?? = nil + ) -> UnimpeachablyClass { + return UnimpeachablyClass( + acerin: acerin ?? self.acerin, + bobadil: bobadil ?? self.bobadil, + catharticalness: catharticalness ?? self.catharticalness, + chirotherium: chirotherium ?? self.chirotherium, + chlorophylligenous: chlorophylligenous ?? self.chlorophylligenous, + conversational: conversational ?? self.conversational, + demiowl: demiowl ?? self.demiowl, + disdiapason: disdiapason ?? self.disdiapason, + ectorhinal: ectorhinal ?? self.ectorhinal, + gamblesomeness: gamblesomeness ?? self.gamblesomeness, + homocerc: homocerc ?? self.homocerc, + irrorate: irrorate ?? self.irrorate, + kindergartening: kindergartening ?? self.kindergartening, + lateritic: lateritic ?? self.lateritic, + mespil: mespil ?? self.mespil, + misconfiguration: misconfiguration ?? self.misconfiguration, + nonbookish: nonbookish ?? self.nonbookish, + planometry: planometry ?? self.planometry, + quiina: quiina ?? self.quiina, + robert: robert ?? self.robert, + rot: rot ?? self.rot, + subcinctorium: subcinctorium ?? self.subcinctorium, + tussocker: tussocker ?? self.tussocker, + ultraproud: ultraproud ?? self.ultraproud, + unsuggestedness: unsuggestedness ?? self.unsuggestedness + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Unmortgaged: Codable, Hashable { + case double(Double) + case integerMap([String: Int]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Unmortgaged.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unmortgaged")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Unobstructed: Codable, Hashable { + case integer(Int) + case quebrachineClass(QuebrachineClass) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode(QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Unobstructed.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unobstructed")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Unreceptivity: Codable, Hashable { + case integer(Int) + case nullArray([JSONNull?]) + case string(String) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + throw DecodingError.typeMismatch(Unreceptivity.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unreceptivity")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .integer(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + } + } +} + +enum Unsatisfactoriness: Codable, Hashable { + case bool(Bool) + case integer(Int) + case integerArray([Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Int.self) { + self = .integer(x) + return + } + if let x = try? container.decode([Int].self) { + self = .integerArray(x) + return + } + throw DecodingError.typeMismatch(Unsatisfactoriness.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unsatisfactoriness")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .integer(let x): + try container.encode(x) + case .integerArray(let x): + try container.encode(x) + } + } +} + +enum UnstressedElement: Codable, Hashable { + case bool(Bool) + case string(String) + case unstressedClass(UnstressedClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(String.self) { + self = .string(x) + return + } + if let x = try? container.decode(UnstressedClass.self) { + self = .unstressedClass(x) + return + } + throw DecodingError.typeMismatch(UnstressedElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for UnstressedElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .string(let x): + try container.encode(x) + case .unstressedClass(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - UnstressedClass +struct UnstressedClass: Codable, Hashable { + let alain: JSONNull? + let amphirhina: JSONNull? + let antimachinery: JSONNull? + let coldish: JSONNull? + let crantara: JSONNull? + let distinguishing: JSONNull? + let elytroposis: JSONNull? + let gentianwort: JSONNull? + let heliosis: JSONNull? + let instrumental: JSONNull? + let introinflection: JSONNull? + let kala: JSONNull? + let lincolnian: JSONNull? + let metad: JSONNull? + let sarcophilus: JSONNull? + let swingingly: JSONNull? + let unconformity: JSONNull? + let undecreed: JSONNull? + let venerable: JSONNull? + let vowellessness: JSONNull? + + enum CodingKeys: String, CodingKey { + case alain = "Alain" + case amphirhina = "Amphirhina" + case antimachinery = "antimachinery" + case coldish = "coldish" + case crantara = "crantara" + case distinguishing = "distinguishing" + case elytroposis = "elytroposis" + case gentianwort = "gentianwort" + case heliosis = "heliosis" + case instrumental = "instrumental" + case introinflection = "introinflection" + case kala = "kala" + case lincolnian = "Lincolnian" + case metad = "metad" + case sarcophilus = "Sarcophilus" + case swingingly = "swingingly" + case unconformity = "unconformity" + case undecreed = "undecreed" + case venerable = "venerable" + case vowellessness = "vowellessness" + } +} + +// MARK: UnstressedClass convenience initializers and mutators + +extension UnstressedClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(UnstressedClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + alain: JSONNull?? = nil, + amphirhina: JSONNull?? = nil, + antimachinery: JSONNull?? = nil, + coldish: JSONNull?? = nil, + crantara: JSONNull?? = nil, + distinguishing: JSONNull?? = nil, + elytroposis: JSONNull?? = nil, + gentianwort: JSONNull?? = nil, + heliosis: JSONNull?? = nil, + instrumental: JSONNull?? = nil, + introinflection: JSONNull?? = nil, + kala: JSONNull?? = nil, + lincolnian: JSONNull?? = nil, + metad: JSONNull?? = nil, + sarcophilus: JSONNull?? = nil, + swingingly: JSONNull?? = nil, + unconformity: JSONNull?? = nil, + undecreed: JSONNull?? = nil, + venerable: JSONNull?? = nil, + vowellessness: JSONNull?? = nil + ) -> UnstressedClass { + return UnstressedClass( + alain: alain ?? self.alain, + amphirhina: amphirhina ?? self.amphirhina, + antimachinery: antimachinery ?? self.antimachinery, + coldish: coldish ?? self.coldish, + crantara: crantara ?? self.crantara, + distinguishing: distinguishing ?? self.distinguishing, + elytroposis: elytroposis ?? self.elytroposis, + gentianwort: gentianwort ?? self.gentianwort, + heliosis: heliosis ?? self.heliosis, + instrumental: instrumental ?? self.instrumental, + introinflection: introinflection ?? self.introinflection, + kala: kala ?? self.kala, + lincolnian: lincolnian ?? self.lincolnian, + metad: metad ?? self.metad, + sarcophilus: sarcophilus ?? self.sarcophilus, + swingingly: swingingly ?? self.swingingly, + unconformity: unconformity ?? self.unconformity, + undecreed: undecreed ?? self.undecreed, + venerable: venerable ?? self.venerable, + vowellessness: vowellessness ?? self.vowellessness + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Untasked: Codable, Hashable { + case double(Double) + case integerMap([String: Int]) + case nullArray([JSONNull?]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Untasked.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Untasked")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + } + } +} + +enum Unvarying: Codable, Hashable { + case bool(Bool) + case double(Double) + case integerMap([String: Int]) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode([String: Int].self) { + self = .integerMap(x) + return + } + throw DecodingError.typeMismatch(Unvarying.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Unvarying")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .double(let x): + try container.encode(x) + case .integerMap(let x): + try container.encode(x) + } + } +} + +enum Vehemently: Codable, Hashable { + case bool(Bool) + case nullArray([JSONNull?]) + case null + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Bool.self) { + self = .bool(x) + return + } + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if container.decodeNil() { + self = .null + return + } + throw DecodingError.typeMismatch(Vehemently.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Vehemently")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .bool(let x): + try container.encode(x) + case .nullArray(let x): + try container.encode(x) + case .null: + try container.encodeNil() + } + } +} + +enum Whitepot: Codable, Hashable { + case double(Double) + case quebrachineClass(QuebrachineClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode(Double.self) { + self = .double(x) + return + } + if let x = try? container.decode(QuebrachineClass.self) { + self = .quebrachineClass(x) + return + } + throw DecodingError.typeMismatch(Whitepot.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for Whitepot")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .double(let x): + try container.encode(x) + case .quebrachineClass(let x): + try container.encode(x) + } + } +} + +enum WrothyElement: Codable, Hashable { + case nullArray([JSONNull?]) + case wrothyClass(WrothyClass) + + init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if let x = try? container.decode([JSONNull?].self) { + self = .nullArray(x) + return + } + if let x = try? container.decode(WrothyClass.self) { + self = .wrothyClass(x) + return + } + throw DecodingError.typeMismatch(WrothyElement.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for WrothyElement")) + } + + func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + switch self { + case .nullArray(let x): + try container.encode(x) + case .wrothyClass(let x): + try container.encode(x) + } + } +} + +// +// Hashable or Equatable: +// The compiler will not be able to synthesize the implementation of Hashable or Equatable +// for types that require the use of JSONAny, nor will the implementation of Hashable be +// synthesized for types that have collections (such as arrays or dictionaries). + +// MARK: - WrothyClass +struct WrothyClass: Codable, Hashable { + let aeschynanthus: JSONNull? + let aquiferous: JSONNull? + let cheapener: JSONNull? + let enumeration: JSONNull? + let ephesine: JSONNull? + let escadrille: JSONNull? + let estrous: JSONNull? + let interestedly: JSONNull? + let katakinetomer: JSONNull? + let mortification: JSONNull? + let morula: JSONNull? + let orthosymmetrical: JSONNull? + let overbark: JSONNull? + let politist: JSONNull? + let qualified: JSONNull? + let sphenomalar: JSONNull? + let throatful: JSONNull? + let transhumance: JSONNull? + let triandrian: JSONNull? + let unbooked: JSONNull? + + enum CodingKeys: String, CodingKey { + case aeschynanthus = "Aeschynanthus" + case aquiferous = "aquiferous" + case cheapener = "cheapener" + case enumeration = "enumeration" + case ephesine = "Ephesine" + case escadrille = "escadrille" + case estrous = "estrous" + case interestedly = "interestedly" + case katakinetomer = "katakinetomer" + case mortification = "mortification" + case morula = "morula" + case orthosymmetrical = "orthosymmetrical" + case overbark = "overbark" + case politist = "politist" + case qualified = "qualified" + case sphenomalar = "sphenomalar" + case throatful = "throatful" + case transhumance = "transhumance" + case triandrian = "triandrian" + case unbooked = "unbooked" + } +} + +// MARK: WrothyClass convenience initializers and mutators + +extension WrothyClass { + init(data: Data) throws { + self = try newJSONDecoder().decode(WrothyClass.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + aeschynanthus: JSONNull?? = nil, + aquiferous: JSONNull?? = nil, + cheapener: JSONNull?? = nil, + enumeration: JSONNull?? = nil, + ephesine: JSONNull?? = nil, + escadrille: JSONNull?? = nil, + estrous: JSONNull?? = nil, + interestedly: JSONNull?? = nil, + katakinetomer: JSONNull?? = nil, + mortification: JSONNull?? = nil, + morula: JSONNull?? = nil, + orthosymmetrical: JSONNull?? = nil, + overbark: JSONNull?? = nil, + politist: JSONNull?? = nil, + qualified: JSONNull?? = nil, + sphenomalar: JSONNull?? = nil, + throatful: JSONNull?? = nil, + transhumance: JSONNull?? = nil, + triandrian: JSONNull?? = nil, + unbooked: JSONNull?? = nil + ) -> WrothyClass { + return WrothyClass( + aeschynanthus: aeschynanthus ?? self.aeschynanthus, + aquiferous: aquiferous ?? self.aquiferous, + cheapener: cheapener ?? self.cheapener, + enumeration: enumeration ?? self.enumeration, + ephesine: ephesine ?? self.ephesine, + escadrille: escadrille ?? self.escadrille, + estrous: estrous ?? self.estrous, + interestedly: interestedly ?? self.interestedly, + katakinetomer: katakinetomer ?? self.katakinetomer, + mortification: mortification ?? self.mortification, + morula: morula ?? self.morula, + orthosymmetrical: orthosymmetrical ?? self.orthosymmetrical, + overbark: overbark ?? self.overbark, + politist: politist ?? self.politist, + qualified: qualified ?? self.qualified, + sphenomalar: sphenomalar ?? self.sphenomalar, + throatful: throatful ?? self.throatful, + transhumance: transhumance ?? self.transhumance, + triandrian: triandrian ?? self.triandrian, + unbooked: unbooked ?? self.unbooked + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - Helper functions for creating encoders and decoders + +func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder +} + +func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} + +// MARK: - Encode/decode helpers + +class JSONNull: Codable, Hashable { + + public static func == (lhs: JSONNull, rhs: JSONNull) -> Bool { + return true + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(0) + } + + public init() {} + + public required init(from decoder: Decoder) throws { + let container = try decoder.singleValueContainer() + if !container.decodeNil() { + throw DecodingError.typeMismatch(JSONNull.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Wrong type for JSONNull")) + } + } + + public func encode(to encoder: Encoder) throws { + var container = encoder.singleValueContainer() + try container.encodeNil() + } +} diff --git a/base/typescript/test/inputs/json/misc/00c36.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/00c36.json/default/TopLevel.ts index 73b98bb..d1e0e64 100644 --- a/base/typescript/test/inputs/json/misc/00c36.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/00c36.json/default/TopLevel.ts @@ -159,7 +159,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/00ec5.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/00ec5.json/default/TopLevel.ts index 074a87e..ca42104 100644 --- a/base/typescript/test/inputs/json/misc/00ec5.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/00ec5.json/default/TopLevel.ts @@ -201,7 +201,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/010b1.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/010b1.json/default/TopLevel.ts index 79fd9ae..2f98523 100644 --- a/base/typescript/test/inputs/json/misc/010b1.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/010b1.json/default/TopLevel.ts @@ -144,7 +144,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/016af.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/016af.json/default/TopLevel.ts index 7855aee..9e038ce 100644 --- a/base/typescript/test/inputs/json/misc/016af.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/016af.json/default/TopLevel.ts @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/033b1.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/033b1.json/default/TopLevel.ts index b23934d..4708e9f 100644 --- a/base/typescript/test/inputs/json/misc/033b1.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/033b1.json/default/TopLevel.ts @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/050b0.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/050b0.json/default/TopLevel.ts index c516128..b57b9e2 100644 --- a/base/typescript/test/inputs/json/misc/050b0.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/050b0.json/default/TopLevel.ts @@ -175,7 +175,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/06bee.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/06bee.json/default/TopLevel.ts index 2e799ab..6cbea0b 100644 --- a/base/typescript/test/inputs/json/misc/06bee.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/06bee.json/default/TopLevel.ts @@ -170,7 +170,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/07540.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/07540.json/default/TopLevel.ts index c2737c3..4f35857 100644 --- a/base/typescript/test/inputs/json/misc/07540.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/07540.json/default/TopLevel.ts @@ -135,7 +135,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/0779f.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/0779f.json/default/TopLevel.ts index 9128987..f737aad 100644 --- a/base/typescript/test/inputs/json/misc/0779f.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/0779f.json/default/TopLevel.ts @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/07c75.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/07c75.json/default/TopLevel.ts index 8140ea8..59e9a64 100644 --- a/base/typescript/test/inputs/json/misc/07c75.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/07c75.json/default/TopLevel.ts @@ -160,7 +160,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/09f54.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/09f54.json/default/TopLevel.ts index b1c5823..4324306 100644 --- a/base/typescript/test/inputs/json/misc/09f54.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/09f54.json/default/TopLevel.ts @@ -148,7 +148,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/0a358.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/0a358.json/default/TopLevel.ts index c0545c9..145129a 100644 --- a/base/typescript/test/inputs/json/misc/0a358.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/0a358.json/default/TopLevel.ts @@ -150,7 +150,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/0a91a.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/0a91a.json/default/TopLevel.ts index 6992073..0877eae 100644 --- a/base/typescript/test/inputs/json/misc/0a91a.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/0a91a.json/default/TopLevel.ts @@ -350,7 +350,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/0b91a.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/0b91a.json/default/TopLevel.ts index c4d4f8a..aeaf842 100644 --- a/base/typescript/test/inputs/json/misc/0b91a.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/0b91a.json/default/TopLevel.ts @@ -176,7 +176,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (typeof typ === "object") { return typ.hasOwnProperty("uuid") ? typeof val === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(val) ? val : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/0cffa.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/0cffa.json/default/TopLevel.ts index 2a08acf..a1c53a3 100644 --- a/base/typescript/test/inputs/json/misc/0cffa.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/0cffa.json/default/TopLevel.ts @@ -243,7 +243,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/0e0c2.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/0e0c2.json/default/TopLevel.ts index d265c20..846dd3e 100644 --- a/base/typescript/test/inputs/json/misc/0e0c2.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/0e0c2.json/default/TopLevel.ts @@ -206,7 +206,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/0fecf.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/0fecf.json/default/TopLevel.ts index 6e4e868..aa2dae4 100644 --- a/base/typescript/test/inputs/json/misc/0fecf.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/0fecf.json/default/TopLevel.ts @@ -135,7 +135,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/10be4.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/10be4.json/default/TopLevel.ts index 48c8c9a..1631a6a 100644 --- a/base/typescript/test/inputs/json/misc/10be4.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/10be4.json/default/TopLevel.ts @@ -175,7 +175,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/112b5.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/112b5.json/default/TopLevel.ts index b7f581f..f5cc84f 100644 --- a/base/typescript/test/inputs/json/misc/112b5.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/112b5.json/default/TopLevel.ts @@ -145,7 +145,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/127a1.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/127a1.json/default/TopLevel.ts index 9669ccb..9a450eb 100644 --- a/base/typescript/test/inputs/json/misc/127a1.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/127a1.json/default/TopLevel.ts @@ -243,7 +243,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/13d8d.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/13d8d.json/default/TopLevel.ts index 2bfdd84..c0763e8 100644 --- a/base/typescript/test/inputs/json/misc/13d8d.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/13d8d.json/default/TopLevel.ts @@ -161,7 +161,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/14d38.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/14d38.json/default/TopLevel.ts index 8ca9cd2..94bbc97 100644 --- a/base/typescript/test/inputs/json/misc/14d38.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/14d38.json/default/TopLevel.ts @@ -142,7 +142,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/167d6.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/167d6.json/default/TopLevel.ts index b23934d..4708e9f 100644 --- a/base/typescript/test/inputs/json/misc/167d6.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/167d6.json/default/TopLevel.ts @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/16bc5.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/16bc5.json/default/TopLevel.ts index 41607fd..cc89913 100644 --- a/base/typescript/test/inputs/json/misc/16bc5.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/16bc5.json/default/TopLevel.ts @@ -233,7 +233,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/176f1.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/176f1.json/default/TopLevel.ts index 90055c0..f22a382 100644 --- a/base/typescript/test/inputs/json/misc/176f1.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/176f1.json/default/TopLevel.ts @@ -160,7 +160,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/1a7f5.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/1a7f5.json/default/TopLevel.ts index 79fd9ae..2f98523 100644 --- a/base/typescript/test/inputs/json/misc/1a7f5.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/1a7f5.json/default/TopLevel.ts @@ -144,7 +144,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/1b28c.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/1b28c.json/default/TopLevel.ts index 7855aee..9e038ce 100644 --- a/base/typescript/test/inputs/json/misc/1b28c.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/1b28c.json/default/TopLevel.ts @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/1b409.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/1b409.json/default/TopLevel.ts index e5c7872..bf751a6 100644 --- a/base/typescript/test/inputs/json/misc/1b409.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/1b409.json/default/TopLevel.ts @@ -209,7 +209,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/2465e.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/2465e.json/default/TopLevel.ts index 2d680db..bd06b10 100644 --- a/base/typescript/test/inputs/json/misc/2465e.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/2465e.json/default/TopLevel.ts @@ -208,7 +208,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/24f52.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/24f52.json/default/TopLevel.ts index 9128987..f737aad 100644 --- a/base/typescript/test/inputs/json/misc/24f52.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/24f52.json/default/TopLevel.ts @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/262f0.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/262f0.json/default/TopLevel.ts index 372a12f..cb90b17 100644 --- a/base/typescript/test/inputs/json/misc/262f0.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/262f0.json/default/TopLevel.ts @@ -235,7 +235,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/26b49.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/26b49.json/default/TopLevel.ts index 9124a6f..d8b2c85 100644 --- a/base/typescript/test/inputs/json/misc/26b49.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/26b49.json/default/TopLevel.ts @@ -242,7 +242,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/26c9c.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/26c9c.json/default/TopLevel.ts index c2f681e..9ea9110 100644 --- a/base/typescript/test/inputs/json/misc/26c9c.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/26c9c.json/default/TopLevel.ts @@ -322,7 +322,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/27332.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/27332.json/default/TopLevel.ts index 78bf8a1..85ba81b 100644 --- a/base/typescript/test/inputs/json/misc/27332.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/27332.json/default/TopLevel.ts @@ -274,7 +274,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/29f47.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/29f47.json/default/TopLevel.ts index da6dbd1..e9fcd58 100644 --- a/base/typescript/test/inputs/json/misc/29f47.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/29f47.json/default/TopLevel.ts @@ -261,7 +261,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/2d4e2.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/2d4e2.json/default/TopLevel.ts index e0060c9..5c42ecf 100644 --- a/base/typescript/test/inputs/json/misc/2d4e2.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/2d4e2.json/default/TopLevel.ts @@ -219,7 +219,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/2df80.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/2df80.json/default/TopLevel.ts index ef56411..5f401af 100644 --- a/base/typescript/test/inputs/json/misc/2df80.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/2df80.json/default/TopLevel.ts @@ -164,7 +164,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/31189.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/31189.json/default/TopLevel.ts index 72c63bb..7d95ecd 100644 --- a/base/typescript/test/inputs/json/misc/31189.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/31189.json/default/TopLevel.ts @@ -162,7 +162,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/32431.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/32431.json/default/TopLevel.ts index 214edbc..9af4c36 100644 --- a/base/typescript/test/inputs/json/misc/32431.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/32431.json/default/TopLevel.ts @@ -198,7 +198,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/32d5c.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/32d5c.json/default/TopLevel.ts index 6824501..3b1c144 100644 --- a/base/typescript/test/inputs/json/misc/32d5c.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/32d5c.json/default/TopLevel.ts @@ -144,7 +144,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/337ed.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/337ed.json/default/TopLevel.ts index cd7228a..5c6908b 100644 --- a/base/typescript/test/inputs/json/misc/337ed.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/337ed.json/default/TopLevel.ts @@ -193,7 +193,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/33d2e.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/33d2e.json/default/TopLevel.ts index dfcd3eb..9275000 100644 --- a/base/typescript/test/inputs/json/misc/33d2e.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/33d2e.json/default/TopLevel.ts @@ -176,7 +176,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/34702.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/34702.json/default/TopLevel.ts index a5ffed5..feed065 100644 --- a/base/typescript/test/inputs/json/misc/34702.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/34702.json/default/TopLevel.ts @@ -190,7 +190,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/3536b.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/3536b.json/default/TopLevel.ts index 0e85deb..6dfce13 100644 --- a/base/typescript/test/inputs/json/misc/3536b.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/3536b.json/default/TopLevel.ts @@ -164,7 +164,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/3659d.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/3659d.json/default/TopLevel.ts index 7855aee..9e038ce 100644 --- a/base/typescript/test/inputs/json/misc/3659d.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/3659d.json/default/TopLevel.ts @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/36d5d.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/36d5d.json/default/TopLevel.ts index 9128987..f737aad 100644 --- a/base/typescript/test/inputs/json/misc/36d5d.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/36d5d.json/default/TopLevel.ts @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/3a6b3.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/3a6b3.json/default/TopLevel.ts index 9128987..f737aad 100644 --- a/base/typescript/test/inputs/json/misc/3a6b3.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/3a6b3.json/default/TopLevel.ts @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/3e9a3.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/3e9a3.json/default/TopLevel.ts index 90055c0..f22a382 100644 --- a/base/typescript/test/inputs/json/misc/3e9a3.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/3e9a3.json/default/TopLevel.ts @@ -160,7 +160,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/3f1ce.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/3f1ce.json/default/TopLevel.ts index 31ba280..524cd8c 100644 --- a/base/typescript/test/inputs/json/misc/3f1ce.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/3f1ce.json/default/TopLevel.ts @@ -235,7 +235,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/421d4.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/421d4.json/default/TopLevel.ts index 98f2455..1a68719 100644 --- a/base/typescript/test/inputs/json/misc/421d4.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/421d4.json/default/TopLevel.ts @@ -246,7 +246,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/437e7.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/437e7.json/default/TopLevel.ts index 72f4754..87f0894 100644 --- a/base/typescript/test/inputs/json/misc/437e7.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/437e7.json/default/TopLevel.ts @@ -239,7 +239,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/43970.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/43970.json/default/TopLevel.ts index 3418e3c..0c1ccc3 100644 --- a/base/typescript/test/inputs/json/misc/43970.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/43970.json/default/TopLevel.ts @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/43eaf.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/43eaf.json/default/TopLevel.ts index b23934d..4708e9f 100644 --- a/base/typescript/test/inputs/json/misc/43eaf.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/43eaf.json/default/TopLevel.ts @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/458db.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/458db.json/default/TopLevel.ts index d32ec59..f8670db 100644 --- a/base/typescript/test/inputs/json/misc/458db.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/458db.json/default/TopLevel.ts @@ -177,7 +177,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (typeof typ === "object") { return typ.hasOwnProperty("uuid") ? typeof val === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(val) ? val : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/4961a.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/4961a.json/default/TopLevel.ts index 7855aee..9e038ce 100644 --- a/base/typescript/test/inputs/json/misc/4961a.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/4961a.json/default/TopLevel.ts @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/4a0d7.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/4a0d7.json/default/TopLevel.ts index 7855aee..9e038ce 100644 --- a/base/typescript/test/inputs/json/misc/4a0d7.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/4a0d7.json/default/TopLevel.ts @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/4a455.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/4a455.json/default/TopLevel.ts index 009ef29..2567151 100644 --- a/base/typescript/test/inputs/json/misc/4a455.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/4a455.json/default/TopLevel.ts @@ -175,7 +175,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/4c547.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/4c547.json/default/TopLevel.ts index 41607fd..cc89913 100644 --- a/base/typescript/test/inputs/json/misc/4c547.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/4c547.json/default/TopLevel.ts @@ -233,7 +233,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/4d6fb.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/4d6fb.json/default/TopLevel.ts index 440fe6a..f5bb8ac 100644 --- a/base/typescript/test/inputs/json/misc/4d6fb.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/4d6fb.json/default/TopLevel.ts @@ -273,7 +273,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/4e336.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/4e336.json/default/TopLevel.ts index 7855aee..9e038ce 100644 --- a/base/typescript/test/inputs/json/misc/4e336.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/4e336.json/default/TopLevel.ts @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/54147.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/54147.json/default/TopLevel.ts index df4bd38..82d2fd7 100644 --- a/base/typescript/test/inputs/json/misc/54147.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/54147.json/default/TopLevel.ts @@ -148,7 +148,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/54d32.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/54d32.json/default/TopLevel.ts index fa60a51..270ed51 100644 --- a/base/typescript/test/inputs/json/misc/54d32.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/54d32.json/default/TopLevel.ts @@ -152,7 +152,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/570ec.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/570ec.json/default/TopLevel.ts index d9fd266..f585dd7 100644 --- a/base/typescript/test/inputs/json/misc/570ec.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/570ec.json/default/TopLevel.ts @@ -167,7 +167,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/5dd0d.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/5dd0d.json/default/TopLevel.ts index 9128987..f737aad 100644 --- a/base/typescript/test/inputs/json/misc/5dd0d.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/5dd0d.json/default/TopLevel.ts @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/5eae5.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/5eae5.json/default/TopLevel.ts index e0539f2..8907265 100644 --- a/base/typescript/test/inputs/json/misc/5eae5.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/5eae5.json/default/TopLevel.ts @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/5eb20.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/5eb20.json/default/TopLevel.ts index 9128987..f737aad 100644 --- a/base/typescript/test/inputs/json/misc/5eb20.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/5eb20.json/default/TopLevel.ts @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/5f3a1.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/5f3a1.json/default/TopLevel.ts index b23934d..4708e9f 100644 --- a/base/typescript/test/inputs/json/misc/5f3a1.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/5f3a1.json/default/TopLevel.ts @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/5f7fe.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/5f7fe.json/default/TopLevel.ts index 2ac1c15..1697b89 100644 --- a/base/typescript/test/inputs/json/misc/5f7fe.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/5f7fe.json/default/TopLevel.ts @@ -320,7 +320,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/617e8.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/617e8.json/default/TopLevel.ts index 9fe7008..183d008 100644 --- a/base/typescript/test/inputs/json/misc/617e8.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/617e8.json/default/TopLevel.ts @@ -319,7 +319,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/61b66.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/61b66.json/default/TopLevel.ts index 9128987..f737aad 100644 --- a/base/typescript/test/inputs/json/misc/61b66.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/61b66.json/default/TopLevel.ts @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/6260a.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/6260a.json/default/TopLevel.ts index b23934d..4708e9f 100644 --- a/base/typescript/test/inputs/json/misc/6260a.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/6260a.json/default/TopLevel.ts @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/65dec.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/65dec.json/default/TopLevel.ts index dfcbff1..c8371ad 100644 --- a/base/typescript/test/inputs/json/misc/65dec.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/65dec.json/default/TopLevel.ts @@ -198,7 +198,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/66121.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/66121.json/default/TopLevel.ts index 5bd7841..dbe517c 100644 --- a/base/typescript/test/inputs/json/misc/66121.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/66121.json/default/TopLevel.ts @@ -170,7 +170,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/6617c.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/6617c.json/default/TopLevel.ts index 1756d7f..d7402d4 100644 --- a/base/typescript/test/inputs/json/misc/6617c.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/6617c.json/default/TopLevel.ts @@ -142,7 +142,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/67c03.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/67c03.json/default/TopLevel.ts index 4be4ecd..c83132c 100644 --- a/base/typescript/test/inputs/json/misc/67c03.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/67c03.json/default/TopLevel.ts @@ -142,7 +142,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/68c30.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/68c30.json/default/TopLevel.ts index 30d1937..131b9d1 100644 --- a/base/typescript/test/inputs/json/misc/68c30.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/68c30.json/default/TopLevel.ts @@ -166,7 +166,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/6c155.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/6c155.json/default/TopLevel.ts index f39c6c9..915e83c 100644 --- a/base/typescript/test/inputs/json/misc/6c155.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/6c155.json/default/TopLevel.ts @@ -189,7 +189,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (typeof typ === "object") { return typ.hasOwnProperty("uuid") ? typeof val === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(val) ? val : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/6de06.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/6de06.json/default/TopLevel.ts index ee7ee7a..3f2914a 100644 --- a/base/typescript/test/inputs/json/misc/6de06.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/6de06.json/default/TopLevel.ts @@ -278,7 +278,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/6dec6.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/6dec6.json/default/TopLevel.ts index 9ab10ee..0277336 100644 --- a/base/typescript/test/inputs/json/misc/6dec6.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/6dec6.json/default/TopLevel.ts @@ -235,7 +235,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/6eb00.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/6eb00.json/default/TopLevel.ts index 5650ebe..db06caa 100644 --- a/base/typescript/test/inputs/json/misc/6eb00.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/6eb00.json/default/TopLevel.ts @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/70c77.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/70c77.json/default/TopLevel.ts index b23934d..4708e9f 100644 --- a/base/typescript/test/inputs/json/misc/70c77.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/70c77.json/default/TopLevel.ts @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/734ad.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/734ad.json/default/TopLevel.ts index ca2f1aa..f93ca5c 100644 --- a/base/typescript/test/inputs/json/misc/734ad.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/734ad.json/default/TopLevel.ts @@ -204,7 +204,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/75912.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/75912.json/default/TopLevel.ts index b23934d..4708e9f 100644 --- a/base/typescript/test/inputs/json/misc/75912.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/75912.json/default/TopLevel.ts @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/7681c.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/7681c.json/default/TopLevel.ts index 05bb9a3..ff9f1c7 100644 --- a/base/typescript/test/inputs/json/misc/7681c.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/7681c.json/default/TopLevel.ts @@ -243,7 +243,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/76ae1.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/76ae1.json/default/TopLevel.ts index d51af86..5162f83 100644 --- a/base/typescript/test/inputs/json/misc/76ae1.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/76ae1.json/default/TopLevel.ts @@ -316,7 +316,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/77392.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/77392.json/default/TopLevel.ts index a9b9662..62d6c4a 100644 --- a/base/typescript/test/inputs/json/misc/77392.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/77392.json/default/TopLevel.ts @@ -150,7 +150,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/7d397.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/7d397.json/default/TopLevel.ts index 3cd089b..e2d58dc 100644 --- a/base/typescript/test/inputs/json/misc/7d397.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/7d397.json/default/TopLevel.ts @@ -208,7 +208,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/7d722.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/7d722.json/default/TopLevel.ts index 9128987..f737aad 100644 --- a/base/typescript/test/inputs/json/misc/7d722.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/7d722.json/default/TopLevel.ts @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/7df41.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/7df41.json/default/TopLevel.ts index 685ba12..e0e13a8 100644 --- a/base/typescript/test/inputs/json/misc/7df41.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/7df41.json/default/TopLevel.ts @@ -145,7 +145,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/7dfa6.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/7dfa6.json/default/TopLevel.ts index 7855aee..9e038ce 100644 --- a/base/typescript/test/inputs/json/misc/7dfa6.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/7dfa6.json/default/TopLevel.ts @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/7eb30.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/7eb30.json/default/TopLevel.ts index 7fdf4a7..6b2ea5c 100644 --- a/base/typescript/test/inputs/json/misc/7eb30.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/7eb30.json/default/TopLevel.ts @@ -172,7 +172,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/7f568.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/7f568.json/default/TopLevel.ts index 02e6961..129c46a 100644 --- a/base/typescript/test/inputs/json/misc/7f568.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/7f568.json/default/TopLevel.ts @@ -164,7 +164,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/7fbfb.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/7fbfb.json/default/TopLevel.ts index 9b02fe5..e6b26ea 100644 --- a/base/typescript/test/inputs/json/misc/7fbfb.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/7fbfb.json/default/TopLevel.ts @@ -159,7 +159,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/80aff.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/80aff.json/default/TopLevel.ts index 99c8d41..507c998 100644 --- a/base/typescript/test/inputs/json/misc/80aff.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/80aff.json/default/TopLevel.ts @@ -151,7 +151,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/82509.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/82509.json/default/TopLevel.ts index 4405c98..764c024 100644 --- a/base/typescript/test/inputs/json/misc/82509.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/82509.json/default/TopLevel.ts @@ -135,7 +135,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/8592b.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/8592b.json/default/TopLevel.ts index a86c84d..365aaf4 100644 --- a/base/typescript/test/inputs/json/misc/8592b.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/8592b.json/default/TopLevel.ts @@ -247,7 +247,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/88130.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/88130.json/default/TopLevel.ts index 41607fd..cc89913 100644 --- a/base/typescript/test/inputs/json/misc/88130.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/88130.json/default/TopLevel.ts @@ -233,7 +233,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/8a62c.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/8a62c.json/default/TopLevel.ts index 7855aee..9e038ce 100644 --- a/base/typescript/test/inputs/json/misc/8a62c.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/8a62c.json/default/TopLevel.ts @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/908db.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/908db.json/default/TopLevel.ts index 643e71d..0678028 100644 --- a/base/typescript/test/inputs/json/misc/908db.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/908db.json/default/TopLevel.ts @@ -144,7 +144,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/9617f.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/9617f.json/default/TopLevel.ts index b23934d..4708e9f 100644 --- a/base/typescript/test/inputs/json/misc/9617f.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/9617f.json/default/TopLevel.ts @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/96f7c.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/96f7c.json/default/TopLevel.ts index fcd9f84..e22ad05 100644 --- a/base/typescript/test/inputs/json/misc/96f7c.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/96f7c.json/default/TopLevel.ts @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/9847b.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/9847b.json/default/TopLevel.ts index ab37fbc..4075396 100644 --- a/base/typescript/test/inputs/json/misc/9847b.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/9847b.json/default/TopLevel.ts @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/9929c.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/9929c.json/default/TopLevel.ts index 41607fd..cc89913 100644 --- a/base/typescript/test/inputs/json/misc/9929c.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/9929c.json/default/TopLevel.ts @@ -233,7 +233,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/996bd.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/996bd.json/default/TopLevel.ts index bd4c7b5..258cc59 100644 --- a/base/typescript/test/inputs/json/misc/996bd.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/996bd.json/default/TopLevel.ts @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/9a503.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/9a503.json/default/TopLevel.ts index 0ce5132..bd955f0 100644 --- a/base/typescript/test/inputs/json/misc/9a503.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/9a503.json/default/TopLevel.ts @@ -162,7 +162,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/9ac3b.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/9ac3b.json/default/TopLevel.ts index de26006..85ac3ca 100644 --- a/base/typescript/test/inputs/json/misc/9ac3b.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/9ac3b.json/default/TopLevel.ts @@ -159,7 +159,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/9eed5.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/9eed5.json/default/TopLevel.ts index 888f5ab..172e97c 100644 --- a/base/typescript/test/inputs/json/misc/9eed5.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/9eed5.json/default/TopLevel.ts @@ -162,7 +162,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/a0496.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/a0496.json/default/TopLevel.ts index 7ffc54f..f86a624 100644 --- a/base/typescript/test/inputs/json/misc/a0496.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/a0496.json/default/TopLevel.ts @@ -153,7 +153,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/a1eca.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/a1eca.json/default/TopLevel.ts index 41607fd..cc89913 100644 --- a/base/typescript/test/inputs/json/misc/a1eca.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/a1eca.json/default/TopLevel.ts @@ -233,7 +233,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/a3d8c.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/a3d8c.json/default/TopLevel.ts index 6856c0f..bca72bd 100644 --- a/base/typescript/test/inputs/json/misc/a3d8c.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/a3d8c.json/default/TopLevel.ts @@ -245,7 +245,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/a45b0.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/a45b0.json/default/TopLevel.ts index 79fd9ae..2f98523 100644 --- a/base/typescript/test/inputs/json/misc/a45b0.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/a45b0.json/default/TopLevel.ts @@ -144,7 +144,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/a71df.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/a71df.json/default/TopLevel.ts index 9128987..f737aad 100644 --- a/base/typescript/test/inputs/json/misc/a71df.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/a71df.json/default/TopLevel.ts @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/a9691.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/a9691.json/default/TopLevel.ts index b23934d..4708e9f 100644 --- a/base/typescript/test/inputs/json/misc/a9691.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/a9691.json/default/TopLevel.ts @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/ab0d1.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/ab0d1.json/default/TopLevel.ts index 79fd9ae..2f98523 100644 --- a/base/typescript/test/inputs/json/misc/ab0d1.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/ab0d1.json/default/TopLevel.ts @@ -144,7 +144,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/abb4b.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/abb4b.json/default/TopLevel.ts index 7855aee..9e038ce 100644 --- a/base/typescript/test/inputs/json/misc/abb4b.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/abb4b.json/default/TopLevel.ts @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/ac944.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/ac944.json/default/TopLevel.ts index b23934d..4708e9f 100644 --- a/base/typescript/test/inputs/json/misc/ac944.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/ac944.json/default/TopLevel.ts @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/ad8be.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/ad8be.json/default/TopLevel.ts index 48c8c9a..1631a6a 100644 --- a/base/typescript/test/inputs/json/misc/ad8be.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/ad8be.json/default/TopLevel.ts @@ -175,7 +175,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/ae7f0.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/ae7f0.json/default/TopLevel.ts index 22417cd..20a4fdc 100644 --- a/base/typescript/test/inputs/json/misc/ae7f0.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/ae7f0.json/default/TopLevel.ts @@ -223,7 +223,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/ae9ca.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/ae9ca.json/default/TopLevel.ts index 0544499..3e0709e 100644 --- a/base/typescript/test/inputs/json/misc/ae9ca.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/ae9ca.json/default/TopLevel.ts @@ -171,7 +171,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/af2d1.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/af2d1.json/default/TopLevel.ts index 71dde19..7d5234c 100644 --- a/base/typescript/test/inputs/json/misc/af2d1.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/af2d1.json/default/TopLevel.ts @@ -221,7 +221,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/b4865.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/b4865.json/default/TopLevel.ts index 8338dc5..e3aa916 100644 --- a/base/typescript/test/inputs/json/misc/b4865.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/b4865.json/default/TopLevel.ts @@ -159,7 +159,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/b6f2c.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/b6f2c.json/default/TopLevel.ts index 7855aee..9e038ce 100644 --- a/base/typescript/test/inputs/json/misc/b6f2c.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/b6f2c.json/default/TopLevel.ts @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/b6fe5.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/b6fe5.json/default/TopLevel.ts index acae7d7..b3d9d2a 100644 --- a/base/typescript/test/inputs/json/misc/b6fe5.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/b6fe5.json/default/TopLevel.ts @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/b9f64.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/b9f64.json/default/TopLevel.ts index f5ee9df..4c629c2 100644 --- a/base/typescript/test/inputs/json/misc/b9f64.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/b9f64.json/default/TopLevel.ts @@ -135,7 +135,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/bb1ec.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/bb1ec.json/default/TopLevel.ts index 7855aee..9e038ce 100644 --- a/base/typescript/test/inputs/json/misc/bb1ec.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/bb1ec.json/default/TopLevel.ts @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/be234.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/be234.json/default/TopLevel.ts index 2e62e5b..eec4e00 100644 --- a/base/typescript/test/inputs/json/misc/be234.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/be234.json/default/TopLevel.ts @@ -284,7 +284,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/c0356.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/c0356.json/default/TopLevel.ts index 1001995..739d830 100644 --- a/base/typescript/test/inputs/json/misc/c0356.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/c0356.json/default/TopLevel.ts @@ -147,7 +147,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/c0a3a.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/c0a3a.json/default/TopLevel.ts index 9128987..f737aad 100644 --- a/base/typescript/test/inputs/json/misc/c0a3a.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/c0a3a.json/default/TopLevel.ts @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/c3303.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/c3303.json/default/TopLevel.ts index 2e7fec8..8569404 100644 --- a/base/typescript/test/inputs/json/misc/c3303.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/c3303.json/default/TopLevel.ts @@ -242,7 +242,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/c6cfd.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/c6cfd.json/default/TopLevel.ts index 4d0865c..6a92ef6 100644 --- a/base/typescript/test/inputs/json/misc/c6cfd.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/c6cfd.json/default/TopLevel.ts @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/c8c7e.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/c8c7e.json/default/TopLevel.ts index 08a8eef..7731042 100644 --- a/base/typescript/test/inputs/json/misc/c8c7e.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/c8c7e.json/default/TopLevel.ts @@ -159,7 +159,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/cb0cc.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/cb0cc.json/default/TopLevel.ts index 2b858ab..d0d04b5 100644 --- a/base/typescript/test/inputs/json/misc/cb0cc.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/cb0cc.json/default/TopLevel.ts @@ -152,7 +152,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/cb81e.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/cb81e.json/default/TopLevel.ts index a621341..2f17ea8 100644 --- a/base/typescript/test/inputs/json/misc/cb81e.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/cb81e.json/default/TopLevel.ts @@ -143,7 +143,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/ccd18.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/ccd18.json/default/TopLevel.ts index 9128987..f737aad 100644 --- a/base/typescript/test/inputs/json/misc/ccd18.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/ccd18.json/default/TopLevel.ts @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/cd238.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/cd238.json/default/TopLevel.ts index 9128987..f737aad 100644 --- a/base/typescript/test/inputs/json/misc/cd238.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/cd238.json/default/TopLevel.ts @@ -168,7 +168,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/cd463.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/cd463.json/default/TopLevel.ts index b23934d..4708e9f 100644 --- a/base/typescript/test/inputs/json/misc/cd463.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/cd463.json/default/TopLevel.ts @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/cda6c.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/cda6c.json/default/TopLevel.ts index fa35a36..f66090b 100644 --- a/base/typescript/test/inputs/json/misc/cda6c.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/cda6c.json/default/TopLevel.ts @@ -159,7 +159,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/cf0d8.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/cf0d8.json/default/TopLevel.ts index 41607fd..cc89913 100644 --- a/base/typescript/test/inputs/json/misc/cf0d8.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/cf0d8.json/default/TopLevel.ts @@ -233,7 +233,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/cfbce.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/cfbce.json/default/TopLevel.ts index b23934d..4708e9f 100644 --- a/base/typescript/test/inputs/json/misc/cfbce.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/cfbce.json/default/TopLevel.ts @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/d0908.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/d0908.json/default/TopLevel.ts index 7855aee..9e038ce 100644 --- a/base/typescript/test/inputs/json/misc/d0908.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/d0908.json/default/TopLevel.ts @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/d23d5.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/d23d5.json/default/TopLevel.ts index 6510c29..85b9e49 100644 --- a/base/typescript/test/inputs/json/misc/d23d5.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/d23d5.json/default/TopLevel.ts @@ -150,7 +150,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/dbfb3.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/dbfb3.json/default/TopLevel.ts index d558381..3acd0aa 100644 --- a/base/typescript/test/inputs/json/misc/dbfb3.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/dbfb3.json/default/TopLevel.ts @@ -235,7 +235,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/dc44f.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/dc44f.json/default/TopLevel.ts index 3ac6e02..e95885c 100644 --- a/base/typescript/test/inputs/json/misc/dc44f.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/dc44f.json/default/TopLevel.ts @@ -203,7 +203,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/dd1ce.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/dd1ce.json/default/TopLevel.ts index 3ac6e02..e95885c 100644 --- a/base/typescript/test/inputs/json/misc/dd1ce.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/dd1ce.json/default/TopLevel.ts @@ -203,7 +203,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/dec3a.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/dec3a.json/default/TopLevel.ts index fb5cea8..4fe9fad 100644 --- a/base/typescript/test/inputs/json/misc/dec3a.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/dec3a.json/default/TopLevel.ts @@ -197,7 +197,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (typeof typ === "object") { return typ.hasOwnProperty("uuid") ? typeof val === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(val) ? val : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/df957.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/df957.json/default/TopLevel.ts index 41607fd..cc89913 100644 --- a/base/typescript/test/inputs/json/misc/df957.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/df957.json/default/TopLevel.ts @@ -233,7 +233,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/e0ac7.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/e0ac7.json/default/TopLevel.ts index 023bf5d..ce9a4ae 100644 --- a/base/typescript/test/inputs/json/misc/e0ac7.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/e0ac7.json/default/TopLevel.ts @@ -241,7 +241,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/e2915.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/e2915.json/default/TopLevel.ts index bd65b7a..d6fbaa8 100644 --- a/base/typescript/test/inputs/json/misc/e2915.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/e2915.json/default/TopLevel.ts @@ -235,7 +235,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/e2a58.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/e2a58.json/default/TopLevel.ts index affca81..b93a73d 100644 --- a/base/typescript/test/inputs/json/misc/e2a58.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/e2a58.json/default/TopLevel.ts @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/e324e.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/e324e.json/default/TopLevel.ts index 93a59a1..201b1e6 100644 --- a/base/typescript/test/inputs/json/misc/e324e.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/e324e.json/default/TopLevel.ts @@ -206,7 +206,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/e53b5.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/e53b5.json/default/TopLevel.ts index 73c880f..6062428 100644 --- a/base/typescript/test/inputs/json/misc/e53b5.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/e53b5.json/default/TopLevel.ts @@ -159,7 +159,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/e64a0.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/e64a0.json/default/TopLevel.ts index b7f581f..f5cc84f 100644 --- a/base/typescript/test/inputs/json/misc/e64a0.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/e64a0.json/default/TopLevel.ts @@ -145,7 +145,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/e8a0b.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/e8a0b.json/default/TopLevel.ts index 79fd9ae..2f98523 100644 --- a/base/typescript/test/inputs/json/misc/e8a0b.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/e8a0b.json/default/TopLevel.ts @@ -144,7 +144,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/e8b04.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/e8b04.json/default/TopLevel.ts index dc2c1c7..af49489 100644 --- a/base/typescript/test/inputs/json/misc/e8b04.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/e8b04.json/default/TopLevel.ts @@ -366,7 +366,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/ed095.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/ed095.json/default/TopLevel.ts index d94fc9b..1e4f07e 100644 --- a/base/typescript/test/inputs/json/misc/ed095.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/ed095.json/default/TopLevel.ts @@ -133,7 +133,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/f22f5.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/f22f5.json/default/TopLevel.ts index 893055b..81aaa64 100644 --- a/base/typescript/test/inputs/json/misc/f22f5.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/f22f5.json/default/TopLevel.ts @@ -221,7 +221,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/f3139.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/f3139.json/default/TopLevel.ts index ab37fbc..4075396 100644 --- a/base/typescript/test/inputs/json/misc/f3139.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/f3139.json/default/TopLevel.ts @@ -138,7 +138,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/f3edf.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/f3edf.json/default/TopLevel.ts index 79fd9ae..2f98523 100644 --- a/base/typescript/test/inputs/json/misc/f3edf.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/f3edf.json/default/TopLevel.ts @@ -144,7 +144,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/f466a.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/f466a.json/default/TopLevel.ts index 79fd9ae..2f98523 100644 --- a/base/typescript/test/inputs/json/misc/f466a.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/f466a.json/default/TopLevel.ts @@ -144,7 +144,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/f6a65.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/f6a65.json/default/TopLevel.ts index 6e2a750..2968cf1 100644 --- a/base/typescript/test/inputs/json/misc/f6a65.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/f6a65.json/default/TopLevel.ts @@ -243,7 +243,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/f74d5.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/f74d5.json/default/TopLevel.ts index 9e78e93..7e0898b 100644 --- a/base/typescript/test/inputs/json/misc/f74d5.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/f74d5.json/default/TopLevel.ts @@ -245,7 +245,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/f82d9.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/f82d9.json/default/TopLevel.ts index ba1b044..6e58d43 100644 --- a/base/typescript/test/inputs/json/misc/f82d9.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/f82d9.json/default/TopLevel.ts @@ -219,7 +219,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/f974d.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/f974d.json/default/TopLevel.ts index e3c3c16..c1f1880 100644 --- a/base/typescript/test/inputs/json/misc/f974d.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/f974d.json/default/TopLevel.ts @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/faff5.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/faff5.json/default/TopLevel.ts index 4f3f849..f177cf0 100644 --- a/base/typescript/test/inputs/json/misc/faff5.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/faff5.json/default/TopLevel.ts @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/fcca3.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/fcca3.json/default/TopLevel.ts index fbd36fb..a785f7b 100644 --- a/base/typescript/test/inputs/json/misc/fcca3.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/fcca3.json/default/TopLevel.ts @@ -345,7 +345,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/misc/fd329.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/fd329.json/default/TopLevel.ts index b1c5823..4324306 100644 --- a/base/typescript/test/inputs/json/misc/fd329.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/fd329.json/default/TopLevel.ts @@ -148,7 +148,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/blns-object.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/blns-object.json/default/TopLevel.ts index 6dd4fac..e59e4b1 100644 --- a/base/typescript/test/inputs/json/priority/blns-object.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/blns-object.json/default/TopLevel.ts @@ -730,7 +730,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/bug2037.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/bug2037.json/default/TopLevel.ts index 0c1d869..1147b68 100644 --- a/base/typescript/test/inputs/json/priority/bug2037.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/bug2037.json/default/TopLevel.ts @@ -143,7 +143,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/bug2521.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/bug2521.json/default/TopLevel.ts index 7f67039..5e2761b 100644 --- a/base/typescript/test/inputs/json/priority/bug2521.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/bug2521.json/default/TopLevel.ts @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/bug2590.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/bug2590.json/default/TopLevel.ts index 180c087..654a539 100644 --- a/base/typescript/test/inputs/json/priority/bug2590.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/bug2590.json/default/TopLevel.ts @@ -141,7 +141,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/bug2663.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/bug2663.json/default/TopLevel.ts index 9f43a0d..4a7d7cc 100644 --- a/base/typescript/test/inputs/json/priority/bug2663.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/bug2663.json/default/TopLevel.ts @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/bug2793.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/bug2793.json/default/TopLevel.ts index 2c6496f..342d03d 100644 --- a/base/typescript/test/inputs/json/priority/bug2793.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/bug2793.json/default/TopLevel.ts @@ -141,7 +141,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/bug427.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/bug427.json/default/TopLevel.ts index 8f6a5a5..b6fa1ff 100644 --- a/base/typescript/test/inputs/json/priority/bug427.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/bug427.json/default/TopLevel.ts @@ -692,7 +692,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/bug790.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/bug790.json/default/TopLevel.ts index 1b8cc69..492f180 100644 --- a/base/typescript/test/inputs/json/priority/bug790.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/bug790.json/default/TopLevel.ts @@ -142,7 +142,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/bug855-short.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/bug855-short.json/default/TopLevel.ts index b39e69e..422ce87 100644 --- a/base/typescript/test/inputs/json/priority/bug855-short.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/bug855-short.json/default/TopLevel.ts @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/bug863.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/bug863.json/default/TopLevel.ts index 239a30e..85a4c25 100644 --- a/base/typescript/test/inputs/json/priority/bug863.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/bug863.json/default/TopLevel.ts @@ -205,7 +205,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/coin-pairs.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/coin-pairs.json/default/TopLevel.ts index f8a2f45..139e863 100644 --- a/base/typescript/test/inputs/json/priority/coin-pairs.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/coin-pairs.json/default/TopLevel.ts @@ -147,7 +147,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations1.json/acronym-style-pascal--d9e0c1bd777a/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations1.json/acronym-style-pascal--d9e0c1bd777a/TopLevel.ts index d56cf48..263c9c7 100644 --- a/base/typescript/test/inputs/json/priority/combinations1.json/acronym-style-pascal--d9e0c1bd777a/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations1.json/acronym-style-pascal--d9e0c1bd777a/TopLevel.ts @@ -527,7 +527,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations1.json/converters-all-objects--3a443babd1cb/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations1.json/converters-all-objects--3a443babd1cb/TopLevel.ts index 2904a51..6262326 100644 --- a/base/typescript/test/inputs/json/priority/combinations1.json/converters-all-objects--3a443babd1cb/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations1.json/converters-all-objects--3a443babd1cb/TopLevel.ts @@ -631,7 +631,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations1.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations1.json/default/TopLevel.ts index d56cf48..263c9c7 100644 --- a/base/typescript/test/inputs/json/priority/combinations1.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations1.json/default/TopLevel.ts @@ -527,7 +527,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations1.json/nice-property-names-true--f4d7920ee2ce/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations1.json/nice-property-names-true--f4d7920ee2ce/TopLevel.ts index ae33627..ce1c585 100644 --- a/base/typescript/test/inputs/json/priority/combinations1.json/nice-property-names-true--f4d7920ee2ce/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations1.json/nice-property-names-true--f4d7920ee2ce/TopLevel.ts @@ -527,7 +527,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/head/typescript/test/inputs/json/priority/combinations1.json/prefer-const-values-true--6b26e4d1265c/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations1.json/prefer-const-values-true--6b26e4d1265c/TopLevel.ts new file mode 100644 index 0000000..263c9c7 --- /dev/null +++ b/head/typescript/test/inputs/json/priority/combinations1.json/prefer-const-values-true--6b26e4d1265c/TopLevel.ts @@ -0,0 +1,909 @@ +// To parse this data: +// +// import { Convert, TopLevel } from "./TopLevel"; +// +// const topLevel = Convert.toTopLevel(json); +// +// These functions will throw an error if the JSON doesn't +// match the expected interface, even if the JSON is valid. + +export interface TopLevel { + centrodesmose: string; + cerograph: CerographElement[]; + chemotherapeutics: ChemotherapeuticElement[]; + cimelia: CimeliaElement[]; + citrated: number; + clinodome: Clinodome[]; + coadjust: CoadjustElement[]; + consilience: Consilience[]; + constructor: Constructor[]; + continuative: Continuative[]; + credulity: CredulityElement[]; + creviced: Creviced[]; + cubiculum: Array<(number | null)[]>; + deruralize: DeruralizeElement[]; + diaereses: DiaereseElement[]; + dissolution: (null[] | null)[]; + downstroke: Downstroke[]; + electrotautomerism: (number | null)[]; + eleutheromania: Eleutheromania[]; + encrust: Encrust; + entomoid: Entomoid[]; + epipaleolithic: Epipaleolithic[]; + expropriable: Expropriable[]; + faggingly: FagginglyElement[]; + fenks: FenkElement[]; + flagmaking: FlagmakingElement[]; + fluorometer: Fluorometer[]; + fulsome: (number | null)[]; + fuzzy: Fuzzy[]; + gardenwards: Gardenward[]; + generalissimo: Generalissimo[]; + habeas: ({ [key: string]: number } | null)[]; + hemicrystalline: Hemicrystalline[]; + hemocoele: HemocoeleElement[]; + hoister: Hoister[]; + hyperpiesis: Hyperpiesi[]; + hyppish: Hyppish[]; + idealizer: Idealizer[]; + incrustator: Incrustator[]; + intentiveness: Intentiveness[]; + interacinar: Interacinar; + intercorrelation: (number[] | null)[]; + jacutinga: Jacutinga[]; +} + +export type CerographElement = CerographClass | null | string; + +export interface CerographClass { + Tolowa: null; + apotropaion: null; + casuary: null; + creaker: null; + disqualification: null; + imperatorious: null; + impermeabilize: null; + metastoma: null; + noctidiurnal: null; + nonreserve: null; + ophthalmotonometry: null; + pailful: null; + pigfish: null; + pongee: null; + prosodical: null; + scrofuloderm: null; + storekeeping: null; + therologist: null; + tradeful: null; + unriveting: null; +} + +export type ChemotherapeuticElement = ChemotherapeuticClass | number; + +export interface ChemotherapeuticClass { + Chirotherium?: number; + Maureen?: null; + angioneurotic?: null; + availment?: null; + bladelet?: null; + catharticalness?: number; + caulis?: null; + chalcus?: null; + disdiapason?: string; + enteradenological?: null; + homocerc?: boolean; + imporosity?: null; + insistently?: null; + intraparietal?: null; + ivied?: null; + nonbookish?: null; + nostochine?: null; + nutcracker?: null; + ofttimes?: null; + phenocryst?: null; + precoincident?: null; + ramiferous?: null; + stagmometer?: null; + tetherball?: null; + unshy?: null; +} + +export type CimeliaElement = number[] | CimeliaClass | null; + +export interface CimeliaClass { + Chirotherium: number; + catharticalness: number; + disdiapason: string; + homocerc: boolean; + nonbookish: null; +} + +export type Clinodome = number | string; + +export type CoadjustElement = CoadjustClass | number; + +export interface CoadjustClass { + Benny?: null; + Chirotherium?: number; + Netherlandish?: null; + Phonelescope?: null; + Sedaceae?: null; + amidosulphonal?: null; + catharticalness?: number; + disdiapason?: string; + ensnare?: null; + homocerc?: boolean; + hybridizer?: null; + leastwise?: null; + lof?: null; + monkhood?: null; + nonbookish?: null; + peonism?: null; + porphyrogeniture?: null; + preindemnify?: null; + rosal?: null; + scalenous?: null; + scopine?: null; + suberinize?: null; + symbiot?: null; + tablefellow?: null; + unchargeable?: null; +} + +export type Consilience = number | { [key: string]: number }; + +export type Constructor = boolean | { [key: string]: number | null }; + +export type Continuative = { [key: string]: number } | string; + +export type CredulityElement = CredulityClass | number | string; + +export interface CredulityClass { + Flavia: null; + Hedychium: null; + Popean: null; + ammonolytic: null; + bushmaster: null; + considering: null; + consuetudinary: null; + embarras: null; + fineness: null; + flaithship: null; + gruffly: null; + leadwort: null; + overseriously: null; + parabola: null; + pectinatodenticulate: null; + pornocrat: null; + quadrisect: null; + seriality: null; + vamphorn: null; + wharp: null; +} + +export type Creviced = boolean | { [key: string]: number } | string; + +export type DeruralizeElement = null[] | boolean | DeruralizeClass; + +export interface DeruralizeClass { + Jehovistic: null; + Paninean: null; + Romney: null; + bockerel: null; + boulder: null; + churrus: null; + counterdigged: null; + dialogite: null; + digenic: null; + dunbird: null; + ergatogyne: null; + fiendful: null; + jackrod: null; + panther: null; + placentigerous: null; + sparm: null; + tocsin: null; + unnicked: null; + unstavable: null; + windfirm: null; +} + +export type DiaereseElement = number[] | boolean | DiaereseClass; + +export interface DiaereseClass { + Amoreuxia: null; + ani: null; + bernicle: null; + blackwasher: null; + blowhard: null; + broma: null; + closecross: null; + congregationalism: null; + grayly: null; + historically: null; + hoast: null; + irretentive: null; + parcener: null; + pedder: null; + pseudoanatomic: null; + rhizocarpian: null; + samel: null; + silker: null; + subdentated: null; + subobscure: null; +} + +export type Downstroke = null[] | boolean | string; + +export type Eleutheromania = number | { [key: string]: number } | string; + +export interface Encrust { + Hibernia: null; + Hibiscus: null; + Lepidosauria: null; + Syllidae: null; + comradely: null; + diacanthous: null; + feminineness: null; + gossamered: null; + lollingly: null; + manager: null; + mechanic: null; + overminuteness: null; + papelonne: null; + plebification: null; + pugmiller: null; + recoveror: null; + spermatoblastic: null; + ungyved: null; + whirlabout: null; + woodenware: null; +} + +export type Entomoid = CimeliaClass | number; + +export type Epipaleolithic = number[] | number; + +export type Expropriable = null[] | CimeliaClass | number; + +export type FagginglyElement = FagginglyClass | number; + +export interface FagginglyClass { + Anglic: null; + Heteromeri: null; + Poinsettia: null; + abranchian: null; + aculeiform: null; + adiaphoristic: null; + adoptionism: null; + antrotomy: null; + coerciveness: null; + decorist: null; + duckhood: null; + hypochnose: null; + lochage: null; + melee: null; + nonconformitant: null; + putatively: null; + semivolatile: null; + soleas: null; + unfastenable: null; + unmillinered: null; +} + +export type FenkElement = FenkClass | string; + +export interface FenkClass { + Dagomba: null; + Guyandot: null; + Reinwardtia: null; + Tritoness: null; + apoise: null; + astronomize: null; + cockhorse: null; + copular: null; + draffy: null; + foreigner: null; + neurogliosis: null; + osmious: null; + palpitate: null; + rebukeable: null; + reservatory: null; + scalt: null; + scripturalize: null; + tintometer: null; + undergrade: null; + undermountain: null; +} + +export type FlagmakingElement = boolean | FlagmakingClass | number; + +export interface FlagmakingClass { + Bunodonta: null; + Hydrocorisae: null; + Notacanthidae: null; + albarco: null; + hornify: null; + hypoglossus: null; + inexpiably: null; + ingratitude: null; + ladyfly: null; + medicament: null; + monogrammatic: null; + nobbut: null; + polyplacophore: null; + proexercise: null; + protoplast: null; + puzzling: null; + splanchnoskeleton: null; + unloveliness: null; + unquarantined: null; + unrenounceable: null; +} + +export type Fluorometer = number | null | string; + +export type Fuzzy = number | { [key: string]: number | null }; + +export type Gardenward = number[] | boolean | string; + +export type Generalissimo = boolean | { [key: string]: number } | null; + +export type Hemicrystalline = CimeliaClass | string; + +export type HemocoeleElement = number[] | HemocoeleClass; + +export interface HemocoeleClass { + Chirotherium?: number; + Walt?: null; + acrogamy?: null; + amelification?: null; + autobiographic?: null; + berat?: null; + catharticalness?: number; + disdiapason?: string; + disproportionably?: null; + erythrite?: null; + graphic?: null; + hepatological?: null; + homocerc?: boolean; + incommensurably?: null; + misaffirm?: null; + nonbookish?: null; + pocketbook?: null; + sclerometric?: null; + stambouline?: null; + stickpin?: null; + tubulure?: null; + undelated?: null; + unsalt?: null; + untutelar?: null; + vagrant?: null; +} + +export type Hoister = CimeliaClass | null | string; + +export type Hyperpiesi = null[] | CimeliaClass | null; + +export type Hyppish = boolean | null | string; + +export type Idealizer = null[] | CimeliaClass | number; + +export type Incrustator = number[] | number | string; + +export type Intentiveness = CimeliaClass | number | string; + +export interface Interacinar { + assapan: number; + benefactorship: boolean; + triseriatim: string; + tubbing: number; + untrimmed: null; +} + +export type Jacutinga = number[] | { [key: string]: number | null }; + +// Converts JSON strings to/from your types +// and asserts the results of JSON.parse at runtime +export class Convert { + public static toTopLevel(json: string): TopLevel { + return cast(JSON.parse(json), r("TopLevel")); + } + + public static topLevelToJson(value: TopLevel): string { + return JSON.stringify(uncast(value, r("TopLevel")), null, 2); + } +} + +function invalidValue(typ: any, val: any, key: any, parent: any = ''): never { + const prettyTyp = prettyTypeName(typ); + const parentText = parent ? ` on ${parent}` : ''; + const keyText = key ? ` for key "${key}"` : ''; + throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`); +} + +function prettyTypeName(typ: any): string { + if (Array.isArray(typ)) { + if (typ.length === 2 && typ[0] === undefined) { + return `an optional ${prettyTypeName(typ[1])}`; + } else { + return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`; + } + } else if (typeof typ === "object" && typ.literal !== undefined) { + return typ.literal; + } else { + return typeof typ; + } +} + +function jsonToJSProps(typ: any): any { + if (typ.jsonToJS === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ }); + typ.jsonToJS = map; + } + return typ.jsonToJS; +} + +function jsToJSONProps(typ: any): any { + if (typ.jsToJSON === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ }); + typ.jsToJSON = map; + } + return typ.jsToJSON; +} + +function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any { + function transformPrimitive(typ: string, val: any): any { + if (typeof typ === typeof val) return val; + return invalidValue(typ, val, key, parent); + } + + function transformUnion(typs: any[], val: any): any { + // val must validate against one typ in typs + const l = typs.length; + for (let i = 0; i < l; i++) { + const typ = typs[i]; + try { + return transform(val, typ, getProps); + } catch (_) {} + } + return invalidValue(typs, val, key, parent); + } + + function transformEnum(cases: string[], val: any): any { + if (cases.indexOf(val) !== -1) return val; + return invalidValue(cases.map(a => { return l(a); }), val, key, parent); + } + + function transformArray(typ: any, val: any): any { + // val must be an array with no invalid elements + if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent); + + return val.map(el => transform(el, typ, getProps)); + } + + function transformDate(val: any): any { + if (val === null) { + return null; + } + const d = new Date(val); + if (isNaN(d.valueOf())) { + return invalidValue(l("Date"), val, key, parent); + } + return d; + } + + function transformObject(props: { [k: string]: any }, additional: any, val: any): any { + if (val === null || typeof val !== "object" || Array.isArray(val)) { + return invalidValue(l(ref || "object"), val, key, parent); + } + const result: any = {}; + Object.getOwnPropertyNames(props).forEach(key => { + const prop = props[key]; + const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined; + result[prop.key] = transform(v, prop.typ, getProps, key, ref); + }); + Object.getOwnPropertyNames(val).forEach(key => { + if (!Object.prototype.hasOwnProperty.call(props, key)) { + result[key] = transform(val[key], additional, getProps, key, ref); + } + }); + return result; + } + + if (typ === "any") return val; + if (typ === null) { + if (val === null) return val; + return invalidValue(typ, val, key, parent); + } + if (typ === false) return invalidValue(typ, val, key, parent); + let ref: any = undefined; + while (typeof typ === "object" && typ.ref !== undefined) { + ref = typ.ref; + typ = typeMap[typ.ref]; + } + if (Array.isArray(typ)) return transformEnum(typ, val); + if (typeof typ === "object") { + return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) + : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) + : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val) + : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val) + : invalidValue(typ, val, key, parent); + } + // Numbers can be parsed by Date but shouldn't be. + if (typ === Date && typeof val !== "number") return transformDate(val); + return transformPrimitive(typ, val); +} + +function cast(val: any, typ: any): T { + return transform(val, typ, jsonToJSProps); +} + +function uncast(val: T, typ: any): any { + return transform(val, typ, jsToJSONProps); +} + +function l(typ: any) { + return { literal: typ }; +} + +function a(typ: any) { + return { arrayItems: typ }; +} + +function i(typ: any) { + return { integer: typ }; +} + +function p(pattern: any) { + return { pattern }; +} + +function s(typ: any, min: any, max: any) { + return { string: typ, min, max }; +} + +function n(typ: any, min: any, max: any) { + return { number: typ, min, max }; +} + +function u(...typs: any[]) { + return { unionMembers: typs }; +} + +function o(props: any[], additional: any) { + return { props, additional }; +} + +function m(additional: any) { + const props: any[] = []; + return { props, additional }; +} + +function r(name: string) { + return { ref: name }; +} + +const typeMap: any = { + "TopLevel": o([ + { json: "centrodesmose", js: "centrodesmose", typ: "" }, + { json: "cerograph", js: "cerograph", typ: a(u(r("CerographClass"), null, "")) }, + { json: "chemotherapeutics", js: "chemotherapeutics", typ: a(u(r("ChemotherapeuticClass"), i(0))) }, + { json: "cimelia", js: "cimelia", typ: a(u(a(i(0)), r("CimeliaClass"), null)) }, + { json: "citrated", js: "citrated", typ: i(0) }, + { json: "clinodome", js: "clinodome", typ: a(u(3.14, "")) }, + { json: "coadjust", js: "coadjust", typ: a(u(r("CoadjustClass"), 3.14)) }, + { json: "consilience", js: "consilience", typ: a(u(3.14, m(i(0)))) }, + { json: "constructor", js: "constructor", typ: a(u(true, m(u(i(0), null)))) }, + { json: "continuative", js: "continuative", typ: a(u(m(i(0)), "")) }, + { json: "credulity", js: "credulity", typ: a(u(r("CredulityClass"), i(0), "")) }, + { json: "creviced", js: "creviced", typ: a(u(true, m(i(0)), "")) }, + { json: "cubiculum", js: "cubiculum", typ: a(a(u(i(0), null))) }, + { json: "deruralize", js: "deruralize", typ: a(u(a(null), true, r("DeruralizeClass"))) }, + { json: "diaereses", js: "diaereses", typ: a(u(a(i(0)), true, r("DiaereseClass"))) }, + { json: "dissolution", js: "dissolution", typ: a(u(a(null), null)) }, + { json: "downstroke", js: "downstroke", typ: a(u(a(null), true, "")) }, + { json: "electrotautomerism", js: "electrotautomerism", typ: a(u(3.14, null)) }, + { json: "eleutheromania", js: "eleutheromania", typ: a(u(3.14, m(i(0)), "")) }, + { json: "encrust", js: "encrust", typ: r("Encrust") }, + { json: "entomoid", js: "entomoid", typ: a(u(r("CimeliaClass"), i(0))) }, + { json: "epipaleolithic", js: "epipaleolithic", typ: a(u(a(i(0)), 3.14)) }, + { json: "expropriable", js: "expropriable", typ: a(u(a(null), r("CimeliaClass"), 3.14)) }, + { json: "faggingly", js: "faggingly", typ: a(u(r("FagginglyClass"), 3.14)) }, + { json: "fenks", js: "fenks", typ: a(u(r("FenkClass"), "")) }, + { json: "flagmaking", js: "flagmaking", typ: a(u(true, r("FlagmakingClass"), 3.14)) }, + { json: "fluorometer", js: "fluorometer", typ: a(u(i(0), null, "")) }, + { json: "fulsome", js: "fulsome", typ: a(u(i(0), null)) }, + { json: "fuzzy", js: "fuzzy", typ: a(u(i(0), m(u(i(0), null)))) }, + { json: "gardenwards", js: "gardenwards", typ: a(u(a(i(0)), true, "")) }, + { json: "generalissimo", js: "generalissimo", typ: a(u(true, m(i(0)), null)) }, + { json: "habeas", js: "habeas", typ: a(u(m(i(0)), null)) }, + { json: "hemicrystalline", js: "hemicrystalline", typ: a(u(r("CimeliaClass"), "")) }, + { json: "hemocoele", js: "hemocoele", typ: a(u(a(i(0)), r("HemocoeleClass"))) }, + { json: "hoister", js: "hoister", typ: a(u(r("CimeliaClass"), null, "")) }, + { json: "hyperpiesis", js: "hyperpiesis", typ: a(u(a(null), r("CimeliaClass"), null)) }, + { json: "hyppish", js: "hyppish", typ: a(u(true, null, "")) }, + { json: "idealizer", js: "idealizer", typ: a(u(a(null), r("CimeliaClass"), i(0))) }, + { json: "incrustator", js: "incrustator", typ: a(u(a(i(0)), i(0), "")) }, + { json: "intentiveness", js: "intentiveness", typ: a(u(r("CimeliaClass"), 3.14, "")) }, + { json: "interacinar", js: "interacinar", typ: r("Interacinar") }, + { json: "intercorrelation", js: "intercorrelation", typ: a(u(a(i(0)), null)) }, + { json: "jacutinga", js: "jacutinga", typ: a(u(a(i(0)), m(u(i(0), null)))) }, + ], false), + "CerographClass": o([ + { json: "Tolowa", js: "Tolowa", typ: null }, + { json: "apotropaion", js: "apotropaion", typ: null }, + { json: "casuary", js: "casuary", typ: null }, + { json: "creaker", js: "creaker", typ: null }, + { json: "disqualification", js: "disqualification", typ: null }, + { json: "imperatorious", js: "imperatorious", typ: null }, + { json: "impermeabilize", js: "impermeabilize", typ: null }, + { json: "metastoma", js: "metastoma", typ: null }, + { json: "noctidiurnal", js: "noctidiurnal", typ: null }, + { json: "nonreserve", js: "nonreserve", typ: null }, + { json: "ophthalmotonometry", js: "ophthalmotonometry", typ: null }, + { json: "pailful", js: "pailful", typ: null }, + { json: "pigfish", js: "pigfish", typ: null }, + { json: "pongee", js: "pongee", typ: null }, + { json: "prosodical", js: "prosodical", typ: null }, + { json: "scrofuloderm", js: "scrofuloderm", typ: null }, + { json: "storekeeping", js: "storekeeping", typ: null }, + { json: "therologist", js: "therologist", typ: null }, + { json: "tradeful", js: "tradeful", typ: null }, + { json: "unriveting", js: "unriveting", typ: null }, + ], false), + "ChemotherapeuticClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Maureen", js: "Maureen", typ: u(undefined, null) }, + { json: "angioneurotic", js: "angioneurotic", typ: u(undefined, null) }, + { json: "availment", js: "availment", typ: u(undefined, null) }, + { json: "bladelet", js: "bladelet", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "caulis", js: "caulis", typ: u(undefined, null) }, + { json: "chalcus", js: "chalcus", typ: u(undefined, null) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "enteradenological", js: "enteradenological", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "imporosity", js: "imporosity", typ: u(undefined, null) }, + { json: "insistently", js: "insistently", typ: u(undefined, null) }, + { json: "intraparietal", js: "intraparietal", typ: u(undefined, null) }, + { json: "ivied", js: "ivied", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "nostochine", js: "nostochine", typ: u(undefined, null) }, + { json: "nutcracker", js: "nutcracker", typ: u(undefined, null) }, + { json: "ofttimes", js: "ofttimes", typ: u(undefined, null) }, + { json: "phenocryst", js: "phenocryst", typ: u(undefined, null) }, + { json: "precoincident", js: "precoincident", typ: u(undefined, null) }, + { json: "ramiferous", js: "ramiferous", typ: u(undefined, null) }, + { json: "stagmometer", js: "stagmometer", typ: u(undefined, null) }, + { json: "tetherball", js: "tetherball", typ: u(undefined, null) }, + { json: "unshy", js: "unshy", typ: u(undefined, null) }, + ], false), + "CimeliaClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: i(0) }, + { json: "catharticalness", js: "catharticalness", typ: 3.14 }, + { json: "disdiapason", js: "disdiapason", typ: "" }, + { json: "homocerc", js: "homocerc", typ: true }, + { json: "nonbookish", js: "nonbookish", typ: null }, + ], false), + "CoadjustClass": o([ + { json: "Benny", js: "Benny", typ: u(undefined, null) }, + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Netherlandish", js: "Netherlandish", typ: u(undefined, null) }, + { json: "Phonelescope", js: "Phonelescope", typ: u(undefined, null) }, + { json: "Sedaceae", js: "Sedaceae", typ: u(undefined, null) }, + { json: "amidosulphonal", js: "amidosulphonal", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "ensnare", js: "ensnare", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "hybridizer", js: "hybridizer", typ: u(undefined, null) }, + { json: "leastwise", js: "leastwise", typ: u(undefined, null) }, + { json: "lof", js: "lof", typ: u(undefined, null) }, + { json: "monkhood", js: "monkhood", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "peonism", js: "peonism", typ: u(undefined, null) }, + { json: "porphyrogeniture", js: "porphyrogeniture", typ: u(undefined, null) }, + { json: "preindemnify", js: "preindemnify", typ: u(undefined, null) }, + { json: "rosal", js: "rosal", typ: u(undefined, null) }, + { json: "scalenous", js: "scalenous", typ: u(undefined, null) }, + { json: "scopine", js: "scopine", typ: u(undefined, null) }, + { json: "suberinize", js: "suberinize", typ: u(undefined, null) }, + { json: "symbiot", js: "symbiot", typ: u(undefined, null) }, + { json: "tablefellow", js: "tablefellow", typ: u(undefined, null) }, + { json: "unchargeable", js: "unchargeable", typ: u(undefined, null) }, + ], false), + "CredulityClass": o([ + { json: "Flavia", js: "Flavia", typ: null }, + { json: "Hedychium", js: "Hedychium", typ: null }, + { json: "Popean", js: "Popean", typ: null }, + { json: "ammonolytic", js: "ammonolytic", typ: null }, + { json: "bushmaster", js: "bushmaster", typ: null }, + { json: "considering", js: "considering", typ: null }, + { json: "consuetudinary", js: "consuetudinary", typ: null }, + { json: "embarras", js: "embarras", typ: null }, + { json: "fineness", js: "fineness", typ: null }, + { json: "flaithship", js: "flaithship", typ: null }, + { json: "gruffly", js: "gruffly", typ: null }, + { json: "leadwort", js: "leadwort", typ: null }, + { json: "overseriously", js: "overseriously", typ: null }, + { json: "parabola", js: "parabola", typ: null }, + { json: "pectinatodenticulate", js: "pectinatodenticulate", typ: null }, + { json: "pornocrat", js: "pornocrat", typ: null }, + { json: "quadrisect", js: "quadrisect", typ: null }, + { json: "seriality", js: "seriality", typ: null }, + { json: "vamphorn", js: "vamphorn", typ: null }, + { json: "wharp", js: "wharp", typ: null }, + ], false), + "DeruralizeClass": o([ + { json: "Jehovistic", js: "Jehovistic", typ: null }, + { json: "Paninean", js: "Paninean", typ: null }, + { json: "Romney", js: "Romney", typ: null }, + { json: "bockerel", js: "bockerel", typ: null }, + { json: "boulder", js: "boulder", typ: null }, + { json: "churrus", js: "churrus", typ: null }, + { json: "counterdigged", js: "counterdigged", typ: null }, + { json: "dialogite", js: "dialogite", typ: null }, + { json: "digenic", js: "digenic", typ: null }, + { json: "dunbird", js: "dunbird", typ: null }, + { json: "ergatogyne", js: "ergatogyne", typ: null }, + { json: "fiendful", js: "fiendful", typ: null }, + { json: "jackrod", js: "jackrod", typ: null }, + { json: "panther", js: "panther", typ: null }, + { json: "placentigerous", js: "placentigerous", typ: null }, + { json: "sparm", js: "sparm", typ: null }, + { json: "tocsin", js: "tocsin", typ: null }, + { json: "unnicked", js: "unnicked", typ: null }, + { json: "unstavable", js: "unstavable", typ: null }, + { json: "windfirm", js: "windfirm", typ: null }, + ], false), + "DiaereseClass": o([ + { json: "Amoreuxia", js: "Amoreuxia", typ: null }, + { json: "ani", js: "ani", typ: null }, + { json: "bernicle", js: "bernicle", typ: null }, + { json: "blackwasher", js: "blackwasher", typ: null }, + { json: "blowhard", js: "blowhard", typ: null }, + { json: "broma", js: "broma", typ: null }, + { json: "closecross", js: "closecross", typ: null }, + { json: "congregationalism", js: "congregationalism", typ: null }, + { json: "grayly", js: "grayly", typ: null }, + { json: "historically", js: "historically", typ: null }, + { json: "hoast", js: "hoast", typ: null }, + { json: "irretentive", js: "irretentive", typ: null }, + { json: "parcener", js: "parcener", typ: null }, + { json: "pedder", js: "pedder", typ: null }, + { json: "pseudoanatomic", js: "pseudoanatomic", typ: null }, + { json: "rhizocarpian", js: "rhizocarpian", typ: null }, + { json: "samel", js: "samel", typ: null }, + { json: "silker", js: "silker", typ: null }, + { json: "subdentated", js: "subdentated", typ: null }, + { json: "subobscure", js: "subobscure", typ: null }, + ], false), + "Encrust": o([ + { json: "Hibernia", js: "Hibernia", typ: null }, + { json: "Hibiscus", js: "Hibiscus", typ: null }, + { json: "Lepidosauria", js: "Lepidosauria", typ: null }, + { json: "Syllidae", js: "Syllidae", typ: null }, + { json: "comradely", js: "comradely", typ: null }, + { json: "diacanthous", js: "diacanthous", typ: null }, + { json: "feminineness", js: "feminineness", typ: null }, + { json: "gossamered", js: "gossamered", typ: null }, + { json: "lollingly", js: "lollingly", typ: null }, + { json: "manager", js: "manager", typ: null }, + { json: "mechanic", js: "mechanic", typ: null }, + { json: "overminuteness", js: "overminuteness", typ: null }, + { json: "papelonne", js: "papelonne", typ: null }, + { json: "plebification", js: "plebification", typ: null }, + { json: "pugmiller", js: "pugmiller", typ: null }, + { json: "recoveror", js: "recoveror", typ: null }, + { json: "spermatoblastic", js: "spermatoblastic", typ: null }, + { json: "ungyved", js: "ungyved", typ: null }, + { json: "whirlabout", js: "whirlabout", typ: null }, + { json: "woodenware", js: "woodenware", typ: null }, + ], false), + "FagginglyClass": o([ + { json: "Anglic", js: "Anglic", typ: null }, + { json: "Heteromeri", js: "Heteromeri", typ: null }, + { json: "Poinsettia", js: "Poinsettia", typ: null }, + { json: "abranchian", js: "abranchian", typ: null }, + { json: "aculeiform", js: "aculeiform", typ: null }, + { json: "adiaphoristic", js: "adiaphoristic", typ: null }, + { json: "adoptionism", js: "adoptionism", typ: null }, + { json: "antrotomy", js: "antrotomy", typ: null }, + { json: "coerciveness", js: "coerciveness", typ: null }, + { json: "decorist", js: "decorist", typ: null }, + { json: "duckhood", js: "duckhood", typ: null }, + { json: "hypochnose", js: "hypochnose", typ: null }, + { json: "lochage", js: "lochage", typ: null }, + { json: "melee", js: "melee", typ: null }, + { json: "nonconformitant", js: "nonconformitant", typ: null }, + { json: "putatively", js: "putatively", typ: null }, + { json: "semivolatile", js: "semivolatile", typ: null }, + { json: "soleas", js: "soleas", typ: null }, + { json: "unfastenable", js: "unfastenable", typ: null }, + { json: "unmillinered", js: "unmillinered", typ: null }, + ], false), + "FenkClass": o([ + { json: "Dagomba", js: "Dagomba", typ: null }, + { json: "Guyandot", js: "Guyandot", typ: null }, + { json: "Reinwardtia", js: "Reinwardtia", typ: null }, + { json: "Tritoness", js: "Tritoness", typ: null }, + { json: "apoise", js: "apoise", typ: null }, + { json: "astronomize", js: "astronomize", typ: null }, + { json: "cockhorse", js: "cockhorse", typ: null }, + { json: "copular", js: "copular", typ: null }, + { json: "draffy", js: "draffy", typ: null }, + { json: "foreigner", js: "foreigner", typ: null }, + { json: "neurogliosis", js: "neurogliosis", typ: null }, + { json: "osmious", js: "osmious", typ: null }, + { json: "palpitate", js: "palpitate", typ: null }, + { json: "rebukeable", js: "rebukeable", typ: null }, + { json: "reservatory", js: "reservatory", typ: null }, + { json: "scalt", js: "scalt", typ: null }, + { json: "scripturalize", js: "scripturalize", typ: null }, + { json: "tintometer", js: "tintometer", typ: null }, + { json: "undergrade", js: "undergrade", typ: null }, + { json: "undermountain", js: "undermountain", typ: null }, + ], false), + "FlagmakingClass": o([ + { json: "Bunodonta", js: "Bunodonta", typ: null }, + { json: "Hydrocorisae", js: "Hydrocorisae", typ: null }, + { json: "Notacanthidae", js: "Notacanthidae", typ: null }, + { json: "albarco", js: "albarco", typ: null }, + { json: "hornify", js: "hornify", typ: null }, + { json: "hypoglossus", js: "hypoglossus", typ: null }, + { json: "inexpiably", js: "inexpiably", typ: null }, + { json: "ingratitude", js: "ingratitude", typ: null }, + { json: "ladyfly", js: "ladyfly", typ: null }, + { json: "medicament", js: "medicament", typ: null }, + { json: "monogrammatic", js: "monogrammatic", typ: null }, + { json: "nobbut", js: "nobbut", typ: null }, + { json: "polyplacophore", js: "polyplacophore", typ: null }, + { json: "proexercise", js: "proexercise", typ: null }, + { json: "protoplast", js: "protoplast", typ: null }, + { json: "puzzling", js: "puzzling", typ: null }, + { json: "splanchnoskeleton", js: "splanchnoskeleton", typ: null }, + { json: "unloveliness", js: "unloveliness", typ: null }, + { json: "unquarantined", js: "unquarantined", typ: null }, + { json: "unrenounceable", js: "unrenounceable", typ: null }, + ], false), + "HemocoeleClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Walt", js: "Walt", typ: u(undefined, null) }, + { json: "acrogamy", js: "acrogamy", typ: u(undefined, null) }, + { json: "amelification", js: "amelification", typ: u(undefined, null) }, + { json: "autobiographic", js: "autobiographic", typ: u(undefined, null) }, + { json: "berat", js: "berat", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "disproportionably", js: "disproportionably", typ: u(undefined, null) }, + { json: "erythrite", js: "erythrite", typ: u(undefined, null) }, + { json: "graphic", js: "graphic", typ: u(undefined, null) }, + { json: "hepatological", js: "hepatological", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "incommensurably", js: "incommensurably", typ: u(undefined, null) }, + { json: "misaffirm", js: "misaffirm", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "pocketbook", js: "pocketbook", typ: u(undefined, null) }, + { json: "sclerometric", js: "sclerometric", typ: u(undefined, null) }, + { json: "stambouline", js: "stambouline", typ: u(undefined, null) }, + { json: "stickpin", js: "stickpin", typ: u(undefined, null) }, + { json: "tubulure", js: "tubulure", typ: u(undefined, null) }, + { json: "undelated", js: "undelated", typ: u(undefined, null) }, + { json: "unsalt", js: "unsalt", typ: u(undefined, null) }, + { json: "untutelar", js: "untutelar", typ: u(undefined, null) }, + { json: "vagrant", js: "vagrant", typ: u(undefined, null) }, + ], false), + "Interacinar": o([ + { json: "assapan", js: "assapan", typ: 3.14 }, + { json: "benefactorship", js: "benefactorship", typ: true }, + { json: "triseriatim", js: "triseriatim", typ: "" }, + { json: "tubbing", js: "tubbing", typ: i(0) }, + { json: "untrimmed", js: "untrimmed", typ: null }, + ], false), +}; diff --git a/head/typescript/test/inputs/json/priority/combinations1.json/prefer-types-true--df33e18681f9/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations1.json/prefer-types-true--df33e18681f9/TopLevel.ts new file mode 100644 index 0000000..31d70cf --- /dev/null +++ b/head/typescript/test/inputs/json/priority/combinations1.json/prefer-types-true--df33e18681f9/TopLevel.ts @@ -0,0 +1,909 @@ +// To parse this data: +// +// import { Convert, TopLevel } from "./TopLevel"; +// +// const topLevel = Convert.toTopLevel(json); +// +// These functions will throw an error if the JSON doesn't +// match the expected interface, even if the JSON is valid. + +export type TopLevel = { + centrodesmose: string; + cerograph: CerographElement[]; + chemotherapeutics: ChemotherapeuticElement[]; + cimelia: CimeliaElement[]; + citrated: number; + clinodome: Clinodome[]; + coadjust: CoadjustElement[]; + consilience: Consilience[]; + constructor: Constructor[]; + continuative: Continuative[]; + credulity: CredulityElement[]; + creviced: Creviced[]; + cubiculum: Array<(number | null)[]>; + deruralize: DeruralizeElement[]; + diaereses: DiaereseElement[]; + dissolution: (null[] | null)[]; + downstroke: Downstroke[]; + electrotautomerism: (number | null)[]; + eleutheromania: Eleutheromania[]; + encrust: Encrust; + entomoid: Entomoid[]; + epipaleolithic: Epipaleolithic[]; + expropriable: Expropriable[]; + faggingly: FagginglyElement[]; + fenks: FenkElement[]; + flagmaking: FlagmakingElement[]; + fluorometer: Fluorometer[]; + fulsome: (number | null)[]; + fuzzy: Fuzzy[]; + gardenwards: Gardenward[]; + generalissimo: Generalissimo[]; + habeas: ({ [key: string]: number } | null)[]; + hemicrystalline: Hemicrystalline[]; + hemocoele: HemocoeleElement[]; + hoister: Hoister[]; + hyperpiesis: Hyperpiesi[]; + hyppish: Hyppish[]; + idealizer: Idealizer[]; + incrustator: Incrustator[]; + intentiveness: Intentiveness[]; + interacinar: Interacinar; + intercorrelation: (number[] | null)[]; + jacutinga: Jacutinga[]; +} + +export type CerographElement = CerographClass | null | string; + +export type CerographClass = { + Tolowa: null; + apotropaion: null; + casuary: null; + creaker: null; + disqualification: null; + imperatorious: null; + impermeabilize: null; + metastoma: null; + noctidiurnal: null; + nonreserve: null; + ophthalmotonometry: null; + pailful: null; + pigfish: null; + pongee: null; + prosodical: null; + scrofuloderm: null; + storekeeping: null; + therologist: null; + tradeful: null; + unriveting: null; +} + +export type ChemotherapeuticElement = ChemotherapeuticClass | number; + +export type ChemotherapeuticClass = { + Chirotherium?: number; + Maureen?: null; + angioneurotic?: null; + availment?: null; + bladelet?: null; + catharticalness?: number; + caulis?: null; + chalcus?: null; + disdiapason?: string; + enteradenological?: null; + homocerc?: boolean; + imporosity?: null; + insistently?: null; + intraparietal?: null; + ivied?: null; + nonbookish?: null; + nostochine?: null; + nutcracker?: null; + ofttimes?: null; + phenocryst?: null; + precoincident?: null; + ramiferous?: null; + stagmometer?: null; + tetherball?: null; + unshy?: null; +} + +export type CimeliaElement = number[] | CimeliaClass | null; + +export type CimeliaClass = { + Chirotherium: number; + catharticalness: number; + disdiapason: string; + homocerc: boolean; + nonbookish: null; +} + +export type Clinodome = number | string; + +export type CoadjustElement = CoadjustClass | number; + +export type CoadjustClass = { + Benny?: null; + Chirotherium?: number; + Netherlandish?: null; + Phonelescope?: null; + Sedaceae?: null; + amidosulphonal?: null; + catharticalness?: number; + disdiapason?: string; + ensnare?: null; + homocerc?: boolean; + hybridizer?: null; + leastwise?: null; + lof?: null; + monkhood?: null; + nonbookish?: null; + peonism?: null; + porphyrogeniture?: null; + preindemnify?: null; + rosal?: null; + scalenous?: null; + scopine?: null; + suberinize?: null; + symbiot?: null; + tablefellow?: null; + unchargeable?: null; +} + +export type Consilience = number | { [key: string]: number }; + +export type Constructor = boolean | { [key: string]: number | null }; + +export type Continuative = { [key: string]: number } | string; + +export type CredulityElement = CredulityClass | number | string; + +export type CredulityClass = { + Flavia: null; + Hedychium: null; + Popean: null; + ammonolytic: null; + bushmaster: null; + considering: null; + consuetudinary: null; + embarras: null; + fineness: null; + flaithship: null; + gruffly: null; + leadwort: null; + overseriously: null; + parabola: null; + pectinatodenticulate: null; + pornocrat: null; + quadrisect: null; + seriality: null; + vamphorn: null; + wharp: null; +} + +export type Creviced = boolean | { [key: string]: number } | string; + +export type DeruralizeElement = null[] | boolean | DeruralizeClass; + +export type DeruralizeClass = { + Jehovistic: null; + Paninean: null; + Romney: null; + bockerel: null; + boulder: null; + churrus: null; + counterdigged: null; + dialogite: null; + digenic: null; + dunbird: null; + ergatogyne: null; + fiendful: null; + jackrod: null; + panther: null; + placentigerous: null; + sparm: null; + tocsin: null; + unnicked: null; + unstavable: null; + windfirm: null; +} + +export type DiaereseElement = number[] | boolean | DiaereseClass; + +export type DiaereseClass = { + Amoreuxia: null; + ani: null; + bernicle: null; + blackwasher: null; + blowhard: null; + broma: null; + closecross: null; + congregationalism: null; + grayly: null; + historically: null; + hoast: null; + irretentive: null; + parcener: null; + pedder: null; + pseudoanatomic: null; + rhizocarpian: null; + samel: null; + silker: null; + subdentated: null; + subobscure: null; +} + +export type Downstroke = null[] | boolean | string; + +export type Eleutheromania = number | { [key: string]: number } | string; + +export type Encrust = { + Hibernia: null; + Hibiscus: null; + Lepidosauria: null; + Syllidae: null; + comradely: null; + diacanthous: null; + feminineness: null; + gossamered: null; + lollingly: null; + manager: null; + mechanic: null; + overminuteness: null; + papelonne: null; + plebification: null; + pugmiller: null; + recoveror: null; + spermatoblastic: null; + ungyved: null; + whirlabout: null; + woodenware: null; +} + +export type Entomoid = CimeliaClass | number; + +export type Epipaleolithic = number[] | number; + +export type Expropriable = null[] | CimeliaClass | number; + +export type FagginglyElement = FagginglyClass | number; + +export type FagginglyClass = { + Anglic: null; + Heteromeri: null; + Poinsettia: null; + abranchian: null; + aculeiform: null; + adiaphoristic: null; + adoptionism: null; + antrotomy: null; + coerciveness: null; + decorist: null; + duckhood: null; + hypochnose: null; + lochage: null; + melee: null; + nonconformitant: null; + putatively: null; + semivolatile: null; + soleas: null; + unfastenable: null; + unmillinered: null; +} + +export type FenkElement = FenkClass | string; + +export type FenkClass = { + Dagomba: null; + Guyandot: null; + Reinwardtia: null; + Tritoness: null; + apoise: null; + astronomize: null; + cockhorse: null; + copular: null; + draffy: null; + foreigner: null; + neurogliosis: null; + osmious: null; + palpitate: null; + rebukeable: null; + reservatory: null; + scalt: null; + scripturalize: null; + tintometer: null; + undergrade: null; + undermountain: null; +} + +export type FlagmakingElement = boolean | FlagmakingClass | number; + +export type FlagmakingClass = { + Bunodonta: null; + Hydrocorisae: null; + Notacanthidae: null; + albarco: null; + hornify: null; + hypoglossus: null; + inexpiably: null; + ingratitude: null; + ladyfly: null; + medicament: null; + monogrammatic: null; + nobbut: null; + polyplacophore: null; + proexercise: null; + protoplast: null; + puzzling: null; + splanchnoskeleton: null; + unloveliness: null; + unquarantined: null; + unrenounceable: null; +} + +export type Fluorometer = number | null | string; + +export type Fuzzy = number | { [key: string]: number | null }; + +export type Gardenward = number[] | boolean | string; + +export type Generalissimo = boolean | { [key: string]: number } | null; + +export type Hemicrystalline = CimeliaClass | string; + +export type HemocoeleElement = number[] | HemocoeleClass; + +export type HemocoeleClass = { + Chirotherium?: number; + Walt?: null; + acrogamy?: null; + amelification?: null; + autobiographic?: null; + berat?: null; + catharticalness?: number; + disdiapason?: string; + disproportionably?: null; + erythrite?: null; + graphic?: null; + hepatological?: null; + homocerc?: boolean; + incommensurably?: null; + misaffirm?: null; + nonbookish?: null; + pocketbook?: null; + sclerometric?: null; + stambouline?: null; + stickpin?: null; + tubulure?: null; + undelated?: null; + unsalt?: null; + untutelar?: null; + vagrant?: null; +} + +export type Hoister = CimeliaClass | null | string; + +export type Hyperpiesi = null[] | CimeliaClass | null; + +export type Hyppish = boolean | null | string; + +export type Idealizer = null[] | CimeliaClass | number; + +export type Incrustator = number[] | number | string; + +export type Intentiveness = CimeliaClass | number | string; + +export type Interacinar = { + assapan: number; + benefactorship: boolean; + triseriatim: string; + tubbing: number; + untrimmed: null; +} + +export type Jacutinga = number[] | { [key: string]: number | null }; + +// Converts JSON strings to/from your types +// and asserts the results of JSON.parse at runtime +export class Convert { + public static toTopLevel(json: string): TopLevel { + return cast(JSON.parse(json), r("TopLevel")); + } + + public static topLevelToJson(value: TopLevel): string { + return JSON.stringify(uncast(value, r("TopLevel")), null, 2); + } +} + +function invalidValue(typ: any, val: any, key: any, parent: any = ''): never { + const prettyTyp = prettyTypeName(typ); + const parentText = parent ? ` on ${parent}` : ''; + const keyText = key ? ` for key "${key}"` : ''; + throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`); +} + +function prettyTypeName(typ: any): string { + if (Array.isArray(typ)) { + if (typ.length === 2 && typ[0] === undefined) { + return `an optional ${prettyTypeName(typ[1])}`; + } else { + return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`; + } + } else if (typeof typ === "object" && typ.literal !== undefined) { + return typ.literal; + } else { + return typeof typ; + } +} + +function jsonToJSProps(typ: any): any { + if (typ.jsonToJS === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ }); + typ.jsonToJS = map; + } + return typ.jsonToJS; +} + +function jsToJSONProps(typ: any): any { + if (typ.jsToJSON === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ }); + typ.jsToJSON = map; + } + return typ.jsToJSON; +} + +function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any { + function transformPrimitive(typ: string, val: any): any { + if (typeof typ === typeof val) return val; + return invalidValue(typ, val, key, parent); + } + + function transformUnion(typs: any[], val: any): any { + // val must validate against one typ in typs + const l = typs.length; + for (let i = 0; i < l; i++) { + const typ = typs[i]; + try { + return transform(val, typ, getProps); + } catch (_) {} + } + return invalidValue(typs, val, key, parent); + } + + function transformEnum(cases: string[], val: any): any { + if (cases.indexOf(val) !== -1) return val; + return invalidValue(cases.map(a => { return l(a); }), val, key, parent); + } + + function transformArray(typ: any, val: any): any { + // val must be an array with no invalid elements + if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent); + + return val.map(el => transform(el, typ, getProps)); + } + + function transformDate(val: any): any { + if (val === null) { + return null; + } + const d = new Date(val); + if (isNaN(d.valueOf())) { + return invalidValue(l("Date"), val, key, parent); + } + return d; + } + + function transformObject(props: { [k: string]: any }, additional: any, val: any): any { + if (val === null || typeof val !== "object" || Array.isArray(val)) { + return invalidValue(l(ref || "object"), val, key, parent); + } + const result: any = {}; + Object.getOwnPropertyNames(props).forEach(key => { + const prop = props[key]; + const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined; + result[prop.key] = transform(v, prop.typ, getProps, key, ref); + }); + Object.getOwnPropertyNames(val).forEach(key => { + if (!Object.prototype.hasOwnProperty.call(props, key)) { + result[key] = transform(val[key], additional, getProps, key, ref); + } + }); + return result; + } + + if (typ === "any") return val; + if (typ === null) { + if (val === null) return val; + return invalidValue(typ, val, key, parent); + } + if (typ === false) return invalidValue(typ, val, key, parent); + let ref: any = undefined; + while (typeof typ === "object" && typ.ref !== undefined) { + ref = typ.ref; + typ = typeMap[typ.ref]; + } + if (Array.isArray(typ)) return transformEnum(typ, val); + if (typeof typ === "object") { + return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) + : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) + : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val) + : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val) + : invalidValue(typ, val, key, parent); + } + // Numbers can be parsed by Date but shouldn't be. + if (typ === Date && typeof val !== "number") return transformDate(val); + return transformPrimitive(typ, val); +} + +function cast(val: any, typ: any): T { + return transform(val, typ, jsonToJSProps); +} + +function uncast(val: T, typ: any): any { + return transform(val, typ, jsToJSONProps); +} + +function l(typ: any) { + return { literal: typ }; +} + +function a(typ: any) { + return { arrayItems: typ }; +} + +function i(typ: any) { + return { integer: typ }; +} + +function p(pattern: any) { + return { pattern }; +} + +function s(typ: any, min: any, max: any) { + return { string: typ, min, max }; +} + +function n(typ: any, min: any, max: any) { + return { number: typ, min, max }; +} + +function u(...typs: any[]) { + return { unionMembers: typs }; +} + +function o(props: any[], additional: any) { + return { props, additional }; +} + +function m(additional: any) { + const props: any[] = []; + return { props, additional }; +} + +function r(name: string) { + return { ref: name }; +} + +const typeMap: any = { + "TopLevel": o([ + { json: "centrodesmose", js: "centrodesmose", typ: "" }, + { json: "cerograph", js: "cerograph", typ: a(u(r("CerographClass"), null, "")) }, + { json: "chemotherapeutics", js: "chemotherapeutics", typ: a(u(r("ChemotherapeuticClass"), i(0))) }, + { json: "cimelia", js: "cimelia", typ: a(u(a(i(0)), r("CimeliaClass"), null)) }, + { json: "citrated", js: "citrated", typ: i(0) }, + { json: "clinodome", js: "clinodome", typ: a(u(3.14, "")) }, + { json: "coadjust", js: "coadjust", typ: a(u(r("CoadjustClass"), 3.14)) }, + { json: "consilience", js: "consilience", typ: a(u(3.14, m(i(0)))) }, + { json: "constructor", js: "constructor", typ: a(u(true, m(u(i(0), null)))) }, + { json: "continuative", js: "continuative", typ: a(u(m(i(0)), "")) }, + { json: "credulity", js: "credulity", typ: a(u(r("CredulityClass"), i(0), "")) }, + { json: "creviced", js: "creviced", typ: a(u(true, m(i(0)), "")) }, + { json: "cubiculum", js: "cubiculum", typ: a(a(u(i(0), null))) }, + { json: "deruralize", js: "deruralize", typ: a(u(a(null), true, r("DeruralizeClass"))) }, + { json: "diaereses", js: "diaereses", typ: a(u(a(i(0)), true, r("DiaereseClass"))) }, + { json: "dissolution", js: "dissolution", typ: a(u(a(null), null)) }, + { json: "downstroke", js: "downstroke", typ: a(u(a(null), true, "")) }, + { json: "electrotautomerism", js: "electrotautomerism", typ: a(u(3.14, null)) }, + { json: "eleutheromania", js: "eleutheromania", typ: a(u(3.14, m(i(0)), "")) }, + { json: "encrust", js: "encrust", typ: r("Encrust") }, + { json: "entomoid", js: "entomoid", typ: a(u(r("CimeliaClass"), i(0))) }, + { json: "epipaleolithic", js: "epipaleolithic", typ: a(u(a(i(0)), 3.14)) }, + { json: "expropriable", js: "expropriable", typ: a(u(a(null), r("CimeliaClass"), 3.14)) }, + { json: "faggingly", js: "faggingly", typ: a(u(r("FagginglyClass"), 3.14)) }, + { json: "fenks", js: "fenks", typ: a(u(r("FenkClass"), "")) }, + { json: "flagmaking", js: "flagmaking", typ: a(u(true, r("FlagmakingClass"), 3.14)) }, + { json: "fluorometer", js: "fluorometer", typ: a(u(i(0), null, "")) }, + { json: "fulsome", js: "fulsome", typ: a(u(i(0), null)) }, + { json: "fuzzy", js: "fuzzy", typ: a(u(i(0), m(u(i(0), null)))) }, + { json: "gardenwards", js: "gardenwards", typ: a(u(a(i(0)), true, "")) }, + { json: "generalissimo", js: "generalissimo", typ: a(u(true, m(i(0)), null)) }, + { json: "habeas", js: "habeas", typ: a(u(m(i(0)), null)) }, + { json: "hemicrystalline", js: "hemicrystalline", typ: a(u(r("CimeliaClass"), "")) }, + { json: "hemocoele", js: "hemocoele", typ: a(u(a(i(0)), r("HemocoeleClass"))) }, + { json: "hoister", js: "hoister", typ: a(u(r("CimeliaClass"), null, "")) }, + { json: "hyperpiesis", js: "hyperpiesis", typ: a(u(a(null), r("CimeliaClass"), null)) }, + { json: "hyppish", js: "hyppish", typ: a(u(true, null, "")) }, + { json: "idealizer", js: "idealizer", typ: a(u(a(null), r("CimeliaClass"), i(0))) }, + { json: "incrustator", js: "incrustator", typ: a(u(a(i(0)), i(0), "")) }, + { json: "intentiveness", js: "intentiveness", typ: a(u(r("CimeliaClass"), 3.14, "")) }, + { json: "interacinar", js: "interacinar", typ: r("Interacinar") }, + { json: "intercorrelation", js: "intercorrelation", typ: a(u(a(i(0)), null)) }, + { json: "jacutinga", js: "jacutinga", typ: a(u(a(i(0)), m(u(i(0), null)))) }, + ], false), + "CerographClass": o([ + { json: "Tolowa", js: "Tolowa", typ: null }, + { json: "apotropaion", js: "apotropaion", typ: null }, + { json: "casuary", js: "casuary", typ: null }, + { json: "creaker", js: "creaker", typ: null }, + { json: "disqualification", js: "disqualification", typ: null }, + { json: "imperatorious", js: "imperatorious", typ: null }, + { json: "impermeabilize", js: "impermeabilize", typ: null }, + { json: "metastoma", js: "metastoma", typ: null }, + { json: "noctidiurnal", js: "noctidiurnal", typ: null }, + { json: "nonreserve", js: "nonreserve", typ: null }, + { json: "ophthalmotonometry", js: "ophthalmotonometry", typ: null }, + { json: "pailful", js: "pailful", typ: null }, + { json: "pigfish", js: "pigfish", typ: null }, + { json: "pongee", js: "pongee", typ: null }, + { json: "prosodical", js: "prosodical", typ: null }, + { json: "scrofuloderm", js: "scrofuloderm", typ: null }, + { json: "storekeeping", js: "storekeeping", typ: null }, + { json: "therologist", js: "therologist", typ: null }, + { json: "tradeful", js: "tradeful", typ: null }, + { json: "unriveting", js: "unriveting", typ: null }, + ], false), + "ChemotherapeuticClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Maureen", js: "Maureen", typ: u(undefined, null) }, + { json: "angioneurotic", js: "angioneurotic", typ: u(undefined, null) }, + { json: "availment", js: "availment", typ: u(undefined, null) }, + { json: "bladelet", js: "bladelet", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "caulis", js: "caulis", typ: u(undefined, null) }, + { json: "chalcus", js: "chalcus", typ: u(undefined, null) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "enteradenological", js: "enteradenological", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "imporosity", js: "imporosity", typ: u(undefined, null) }, + { json: "insistently", js: "insistently", typ: u(undefined, null) }, + { json: "intraparietal", js: "intraparietal", typ: u(undefined, null) }, + { json: "ivied", js: "ivied", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "nostochine", js: "nostochine", typ: u(undefined, null) }, + { json: "nutcracker", js: "nutcracker", typ: u(undefined, null) }, + { json: "ofttimes", js: "ofttimes", typ: u(undefined, null) }, + { json: "phenocryst", js: "phenocryst", typ: u(undefined, null) }, + { json: "precoincident", js: "precoincident", typ: u(undefined, null) }, + { json: "ramiferous", js: "ramiferous", typ: u(undefined, null) }, + { json: "stagmometer", js: "stagmometer", typ: u(undefined, null) }, + { json: "tetherball", js: "tetherball", typ: u(undefined, null) }, + { json: "unshy", js: "unshy", typ: u(undefined, null) }, + ], false), + "CimeliaClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: i(0) }, + { json: "catharticalness", js: "catharticalness", typ: 3.14 }, + { json: "disdiapason", js: "disdiapason", typ: "" }, + { json: "homocerc", js: "homocerc", typ: true }, + { json: "nonbookish", js: "nonbookish", typ: null }, + ], false), + "CoadjustClass": o([ + { json: "Benny", js: "Benny", typ: u(undefined, null) }, + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Netherlandish", js: "Netherlandish", typ: u(undefined, null) }, + { json: "Phonelescope", js: "Phonelescope", typ: u(undefined, null) }, + { json: "Sedaceae", js: "Sedaceae", typ: u(undefined, null) }, + { json: "amidosulphonal", js: "amidosulphonal", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "ensnare", js: "ensnare", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "hybridizer", js: "hybridizer", typ: u(undefined, null) }, + { json: "leastwise", js: "leastwise", typ: u(undefined, null) }, + { json: "lof", js: "lof", typ: u(undefined, null) }, + { json: "monkhood", js: "monkhood", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "peonism", js: "peonism", typ: u(undefined, null) }, + { json: "porphyrogeniture", js: "porphyrogeniture", typ: u(undefined, null) }, + { json: "preindemnify", js: "preindemnify", typ: u(undefined, null) }, + { json: "rosal", js: "rosal", typ: u(undefined, null) }, + { json: "scalenous", js: "scalenous", typ: u(undefined, null) }, + { json: "scopine", js: "scopine", typ: u(undefined, null) }, + { json: "suberinize", js: "suberinize", typ: u(undefined, null) }, + { json: "symbiot", js: "symbiot", typ: u(undefined, null) }, + { json: "tablefellow", js: "tablefellow", typ: u(undefined, null) }, + { json: "unchargeable", js: "unchargeable", typ: u(undefined, null) }, + ], false), + "CredulityClass": o([ + { json: "Flavia", js: "Flavia", typ: null }, + { json: "Hedychium", js: "Hedychium", typ: null }, + { json: "Popean", js: "Popean", typ: null }, + { json: "ammonolytic", js: "ammonolytic", typ: null }, + { json: "bushmaster", js: "bushmaster", typ: null }, + { json: "considering", js: "considering", typ: null }, + { json: "consuetudinary", js: "consuetudinary", typ: null }, + { json: "embarras", js: "embarras", typ: null }, + { json: "fineness", js: "fineness", typ: null }, + { json: "flaithship", js: "flaithship", typ: null }, + { json: "gruffly", js: "gruffly", typ: null }, + { json: "leadwort", js: "leadwort", typ: null }, + { json: "overseriously", js: "overseriously", typ: null }, + { json: "parabola", js: "parabola", typ: null }, + { json: "pectinatodenticulate", js: "pectinatodenticulate", typ: null }, + { json: "pornocrat", js: "pornocrat", typ: null }, + { json: "quadrisect", js: "quadrisect", typ: null }, + { json: "seriality", js: "seriality", typ: null }, + { json: "vamphorn", js: "vamphorn", typ: null }, + { json: "wharp", js: "wharp", typ: null }, + ], false), + "DeruralizeClass": o([ + { json: "Jehovistic", js: "Jehovistic", typ: null }, + { json: "Paninean", js: "Paninean", typ: null }, + { json: "Romney", js: "Romney", typ: null }, + { json: "bockerel", js: "bockerel", typ: null }, + { json: "boulder", js: "boulder", typ: null }, + { json: "churrus", js: "churrus", typ: null }, + { json: "counterdigged", js: "counterdigged", typ: null }, + { json: "dialogite", js: "dialogite", typ: null }, + { json: "digenic", js: "digenic", typ: null }, + { json: "dunbird", js: "dunbird", typ: null }, + { json: "ergatogyne", js: "ergatogyne", typ: null }, + { json: "fiendful", js: "fiendful", typ: null }, + { json: "jackrod", js: "jackrod", typ: null }, + { json: "panther", js: "panther", typ: null }, + { json: "placentigerous", js: "placentigerous", typ: null }, + { json: "sparm", js: "sparm", typ: null }, + { json: "tocsin", js: "tocsin", typ: null }, + { json: "unnicked", js: "unnicked", typ: null }, + { json: "unstavable", js: "unstavable", typ: null }, + { json: "windfirm", js: "windfirm", typ: null }, + ], false), + "DiaereseClass": o([ + { json: "Amoreuxia", js: "Amoreuxia", typ: null }, + { json: "ani", js: "ani", typ: null }, + { json: "bernicle", js: "bernicle", typ: null }, + { json: "blackwasher", js: "blackwasher", typ: null }, + { json: "blowhard", js: "blowhard", typ: null }, + { json: "broma", js: "broma", typ: null }, + { json: "closecross", js: "closecross", typ: null }, + { json: "congregationalism", js: "congregationalism", typ: null }, + { json: "grayly", js: "grayly", typ: null }, + { json: "historically", js: "historically", typ: null }, + { json: "hoast", js: "hoast", typ: null }, + { json: "irretentive", js: "irretentive", typ: null }, + { json: "parcener", js: "parcener", typ: null }, + { json: "pedder", js: "pedder", typ: null }, + { json: "pseudoanatomic", js: "pseudoanatomic", typ: null }, + { json: "rhizocarpian", js: "rhizocarpian", typ: null }, + { json: "samel", js: "samel", typ: null }, + { json: "silker", js: "silker", typ: null }, + { json: "subdentated", js: "subdentated", typ: null }, + { json: "subobscure", js: "subobscure", typ: null }, + ], false), + "Encrust": o([ + { json: "Hibernia", js: "Hibernia", typ: null }, + { json: "Hibiscus", js: "Hibiscus", typ: null }, + { json: "Lepidosauria", js: "Lepidosauria", typ: null }, + { json: "Syllidae", js: "Syllidae", typ: null }, + { json: "comradely", js: "comradely", typ: null }, + { json: "diacanthous", js: "diacanthous", typ: null }, + { json: "feminineness", js: "feminineness", typ: null }, + { json: "gossamered", js: "gossamered", typ: null }, + { json: "lollingly", js: "lollingly", typ: null }, + { json: "manager", js: "manager", typ: null }, + { json: "mechanic", js: "mechanic", typ: null }, + { json: "overminuteness", js: "overminuteness", typ: null }, + { json: "papelonne", js: "papelonne", typ: null }, + { json: "plebification", js: "plebification", typ: null }, + { json: "pugmiller", js: "pugmiller", typ: null }, + { json: "recoveror", js: "recoveror", typ: null }, + { json: "spermatoblastic", js: "spermatoblastic", typ: null }, + { json: "ungyved", js: "ungyved", typ: null }, + { json: "whirlabout", js: "whirlabout", typ: null }, + { json: "woodenware", js: "woodenware", typ: null }, + ], false), + "FagginglyClass": o([ + { json: "Anglic", js: "Anglic", typ: null }, + { json: "Heteromeri", js: "Heteromeri", typ: null }, + { json: "Poinsettia", js: "Poinsettia", typ: null }, + { json: "abranchian", js: "abranchian", typ: null }, + { json: "aculeiform", js: "aculeiform", typ: null }, + { json: "adiaphoristic", js: "adiaphoristic", typ: null }, + { json: "adoptionism", js: "adoptionism", typ: null }, + { json: "antrotomy", js: "antrotomy", typ: null }, + { json: "coerciveness", js: "coerciveness", typ: null }, + { json: "decorist", js: "decorist", typ: null }, + { json: "duckhood", js: "duckhood", typ: null }, + { json: "hypochnose", js: "hypochnose", typ: null }, + { json: "lochage", js: "lochage", typ: null }, + { json: "melee", js: "melee", typ: null }, + { json: "nonconformitant", js: "nonconformitant", typ: null }, + { json: "putatively", js: "putatively", typ: null }, + { json: "semivolatile", js: "semivolatile", typ: null }, + { json: "soleas", js: "soleas", typ: null }, + { json: "unfastenable", js: "unfastenable", typ: null }, + { json: "unmillinered", js: "unmillinered", typ: null }, + ], false), + "FenkClass": o([ + { json: "Dagomba", js: "Dagomba", typ: null }, + { json: "Guyandot", js: "Guyandot", typ: null }, + { json: "Reinwardtia", js: "Reinwardtia", typ: null }, + { json: "Tritoness", js: "Tritoness", typ: null }, + { json: "apoise", js: "apoise", typ: null }, + { json: "astronomize", js: "astronomize", typ: null }, + { json: "cockhorse", js: "cockhorse", typ: null }, + { json: "copular", js: "copular", typ: null }, + { json: "draffy", js: "draffy", typ: null }, + { json: "foreigner", js: "foreigner", typ: null }, + { json: "neurogliosis", js: "neurogliosis", typ: null }, + { json: "osmious", js: "osmious", typ: null }, + { json: "palpitate", js: "palpitate", typ: null }, + { json: "rebukeable", js: "rebukeable", typ: null }, + { json: "reservatory", js: "reservatory", typ: null }, + { json: "scalt", js: "scalt", typ: null }, + { json: "scripturalize", js: "scripturalize", typ: null }, + { json: "tintometer", js: "tintometer", typ: null }, + { json: "undergrade", js: "undergrade", typ: null }, + { json: "undermountain", js: "undermountain", typ: null }, + ], false), + "FlagmakingClass": o([ + { json: "Bunodonta", js: "Bunodonta", typ: null }, + { json: "Hydrocorisae", js: "Hydrocorisae", typ: null }, + { json: "Notacanthidae", js: "Notacanthidae", typ: null }, + { json: "albarco", js: "albarco", typ: null }, + { json: "hornify", js: "hornify", typ: null }, + { json: "hypoglossus", js: "hypoglossus", typ: null }, + { json: "inexpiably", js: "inexpiably", typ: null }, + { json: "ingratitude", js: "ingratitude", typ: null }, + { json: "ladyfly", js: "ladyfly", typ: null }, + { json: "medicament", js: "medicament", typ: null }, + { json: "monogrammatic", js: "monogrammatic", typ: null }, + { json: "nobbut", js: "nobbut", typ: null }, + { json: "polyplacophore", js: "polyplacophore", typ: null }, + { json: "proexercise", js: "proexercise", typ: null }, + { json: "protoplast", js: "protoplast", typ: null }, + { json: "puzzling", js: "puzzling", typ: null }, + { json: "splanchnoskeleton", js: "splanchnoskeleton", typ: null }, + { json: "unloveliness", js: "unloveliness", typ: null }, + { json: "unquarantined", js: "unquarantined", typ: null }, + { json: "unrenounceable", js: "unrenounceable", typ: null }, + ], false), + "HemocoeleClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Walt", js: "Walt", typ: u(undefined, null) }, + { json: "acrogamy", js: "acrogamy", typ: u(undefined, null) }, + { json: "amelification", js: "amelification", typ: u(undefined, null) }, + { json: "autobiographic", js: "autobiographic", typ: u(undefined, null) }, + { json: "berat", js: "berat", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "disproportionably", js: "disproportionably", typ: u(undefined, null) }, + { json: "erythrite", js: "erythrite", typ: u(undefined, null) }, + { json: "graphic", js: "graphic", typ: u(undefined, null) }, + { json: "hepatological", js: "hepatological", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "incommensurably", js: "incommensurably", typ: u(undefined, null) }, + { json: "misaffirm", js: "misaffirm", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "pocketbook", js: "pocketbook", typ: u(undefined, null) }, + { json: "sclerometric", js: "sclerometric", typ: u(undefined, null) }, + { json: "stambouline", js: "stambouline", typ: u(undefined, null) }, + { json: "stickpin", js: "stickpin", typ: u(undefined, null) }, + { json: "tubulure", js: "tubulure", typ: u(undefined, null) }, + { json: "undelated", js: "undelated", typ: u(undefined, null) }, + { json: "unsalt", js: "unsalt", typ: u(undefined, null) }, + { json: "untutelar", js: "untutelar", typ: u(undefined, null) }, + { json: "vagrant", js: "vagrant", typ: u(undefined, null) }, + ], false), + "Interacinar": o([ + { json: "assapan", js: "assapan", typ: 3.14 }, + { json: "benefactorship", js: "benefactorship", typ: true }, + { json: "triseriatim", js: "triseriatim", typ: "" }, + { json: "tubbing", js: "tubbing", typ: i(0) }, + { json: "untrimmed", js: "untrimmed", typ: null }, + ], false), +}; diff --git a/base/typescript/test/inputs/json/priority/combinations1.json/prefer-unions-false--a5053c0a486d/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations1.json/prefer-unions-false--a5053c0a486d/TopLevel.ts index d56cf48..263c9c7 100644 --- a/base/typescript/test/inputs/json/priority/combinations1.json/prefer-unions-false--a5053c0a486d/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations1.json/prefer-unions-false--a5053c0a486d/TopLevel.ts @@ -527,7 +527,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations1.json/prefer-unknown-false--f1ab9e45d823/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations1.json/prefer-unknown-false--f1ab9e45d823/TopLevel.ts index d56cf48..263c9c7 100644 --- a/base/typescript/test/inputs/json/priority/combinations1.json/prefer-unknown-false--f1ab9e45d823/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations1.json/prefer-unknown-false--f1ab9e45d823/TopLevel.ts @@ -527,7 +527,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations1.json/readonly-true--24da4fc107df/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations1.json/readonly-true--24da4fc107df/TopLevel.ts index 9a7d870..3d18ca0 100644 --- a/base/typescript/test/inputs/json/priority/combinations1.json/readonly-true--24da4fc107df/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations1.json/readonly-true--24da4fc107df/TopLevel.ts @@ -527,7 +527,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations1.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations1.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.ts index 8993253..02e7a57 100644 --- a/base/typescript/test/inputs/json/priority/combinations1.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations1.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.ts @@ -527,7 +527,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations2.json/acronym-style-pascal--d9e0c1bd777a/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations2.json/acronym-style-pascal--d9e0c1bd777a/TopLevel.ts index fd1800c..1672405 100644 --- a/base/typescript/test/inputs/json/priority/combinations2.json/acronym-style-pascal--d9e0c1bd777a/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations2.json/acronym-style-pascal--d9e0c1bd777a/TopLevel.ts @@ -479,7 +479,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations2.json/converters-all-objects--3a443babd1cb/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations2.json/converters-all-objects--3a443babd1cb/TopLevel.ts index 7f22084..34f35e5 100644 --- a/base/typescript/test/inputs/json/priority/combinations2.json/converters-all-objects--3a443babd1cb/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations2.json/converters-all-objects--3a443babd1cb/TopLevel.ts @@ -559,7 +559,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations2.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations2.json/default/TopLevel.ts index fd1800c..1672405 100644 --- a/base/typescript/test/inputs/json/priority/combinations2.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations2.json/default/TopLevel.ts @@ -479,7 +479,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations2.json/nice-property-names-true--f4d7920ee2ce/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations2.json/nice-property-names-true--f4d7920ee2ce/TopLevel.ts index d12ba7e..f3cf2db 100644 --- a/base/typescript/test/inputs/json/priority/combinations2.json/nice-property-names-true--f4d7920ee2ce/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations2.json/nice-property-names-true--f4d7920ee2ce/TopLevel.ts @@ -479,7 +479,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/head/typescript/test/inputs/json/priority/combinations2.json/prefer-const-values-true--6b26e4d1265c/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations2.json/prefer-const-values-true--6b26e4d1265c/TopLevel.ts new file mode 100644 index 0000000..1672405 --- /dev/null +++ b/head/typescript/test/inputs/json/priority/combinations2.json/prefer-const-values-true--6b26e4d1265c/TopLevel.ts @@ -0,0 +1,812 @@ +// To parse this data: +// +// import { Convert, TopLevel } from "./TopLevel"; +// +// const topLevel = Convert.toTopLevel(json); +// +// These functions will throw an error if the JSON doesn't +// match the expected interface, even if the JSON is valid. + +export interface TopLevel { + Abranchiata: Abranchiata[]; + Andriana: (null | string)[]; + Ansarie: AnsarieElement[]; + Chytridiaceae: ChytridiaceaeElement[]; + Discordia: DiscordiaElement[]; + Endomyces: Endomyce[]; + Epinephelidae: Epinephelidae[]; + Eupatorium: Eupatorium[]; + Gryphosaurus: GryphosaurusElement[]; + Koryak: Koryak[]; + Lavinia: LaviniaElement[]; + Oskar: OskarElement[]; + Rebecca: RebeccaElement[]; + Rhomboganoidei: Rhomboganoidei[]; + Rigsmal: boolean; + Ruellia: Ruellia[]; + School: School[]; + Shakespearolater: Shakespearolater[]; + Svan: number[]; + Wayao: { [key: string]: number }; + academe: Academe[]; + acquirable: Acquirable[]; + aerometry: Aerometry[]; + alexin: Alexin[]; + alleviate: AlleviateElement[]; + amaas: Amaa[]; + ambassage: Ambassage[]; + amphithyron: (Amphithyron | null)[]; + ankee: AnkeeElement[]; + annihilator: ({ [key: string]: number | null } | null)[]; + annulose: null; + aphasia: Aphasia[]; + asprawl: Asprawl[]; + attractive: (boolean | null)[]; + barksome: { [key: string]: number }; + bedesman: Bedesman[]; + belard: Belard[]; + bocking: Bocking[]; + brawlingly: Brawlingly[]; + brookie: Brookie[]; + bumboatman: Bumboatman[]; + bystreet: null[]; + calaverite: Calaverite[]; + catallactic: Catallactic[]; + cemental: Cemental[]; +} + +export type Abranchiata = number[] | number | null; + +export type AnsarieElement = number[] | AnsarieClass | null; + +export interface AnsarieClass { + Alida: null; + Ictonyx: null; + Ramist: null; + accension: null; + asteria: null; + beriberic: null; + edgebone: null; + gastrodialysis: null; + geographic: null; + metrocele: null; + misgraft: null; + monteith: null; + notcher: null; + prorestriction: null; + throatlet: null; + unfair: null; + unsynonymous: null; + water: null; + zestfully: null; + zincic: null; +} + +export type ChytridiaceaeElement = boolean | ChytridiaceaeClass | null; + +export interface ChytridiaceaeClass { + Batidaceae: null; + Brechites: null; + Emery: null; + Narraganset: null; + codespairer: null; + enervative: null; + excriminate: null; + goshenite: null; + grime: null; + gritten: null; + hectorly: null; + intermediation: null; + meeterly: null; + onymatic: null; + paddlecock: null; + thana: null; + thornily: null; + uckia: null; + unmettle: null; + vorticellid: null; +} + +export type DiscordiaElement = number[] | DiscordiaClass; + +export interface DiscordiaClass { + Altaic?: number; + Chirotherium?: number; + Patarin?: number; + amoristic?: number; + blennophthalmia?: number; + catharticalness?: number; + disciplinability?: number; + disdiapason?: string; + goofer?: number; + homocerc?: boolean; + laryngograph?: number; + leucitis?: number; + lymphocyst?: number; + microcosmology?: number; + nauseation?: number; + nonbookish?: null; + preliberal?: number; + prettifier?: number; + rangework?: number; + redient?: number; + subfusiform?: number; + suicidical?: number; + swow?: number; + wastrel?: number; + wingle?: number; +} + +export type Endomyce = number | string; + +export type Epinephelidae = boolean | number | string; + +export type Eupatorium = null[] | { [key: string]: number }; + +export type GryphosaurusElement = number[] | GryphosaurusClass | string; + +export interface GryphosaurusClass { + Burushaski: null; + Tahami: null; + amissibility: null; + citronin: null; + coplaintiff: null; + disquisitionary: null; + enoplan: null; + faintness: null; + hebetomy: null; + islandry: null; + lameduck: null; + overbattle: null; + overinterested: null; + phrenologic: null; + rainband: null; + shiningly: null; + stamineous: null; + subscapularis: null; + undaubed: null; + underntime: null; +} + +export type Koryak = { [key: string]: number | null } | string; + +export type LaviniaElement = LaviniaClass | string; + +export interface LaviniaClass { + Chirotherium?: number; + Tacana?: number; + agitable?: number; + asininity?: number; + benefiter?: number; + bronzelike?: number; + catharticalness?: number; + cholesteatomatous?: number; + deprivement?: number; + disdiapason?: string; + flippantness?: number; + fogproof?: number; + homocerc?: boolean; + merrymeeting?: number; + nonbookish?: null; + overcareful?: number; + panaris?: number; + preacceptance?: number; + quinoxaline?: number; + sig?: number; + superconfusion?: number; + tillotter?: number; + tranquillize?: number; + unquestionable?: number; + uproute?: number; +} + +export type OskarElement = number[] | OskarClass; + +export interface OskarClass { + Acrobates: null; + Cayuga: null; + Netherlandish: null; + beanshooter: null; + bearhound: null; + guarneri: null; + hypochondriacism: null; + indication: null; + jaculative: null; + nagana: null; + noctivagous: null; + nonphysiological: null; + praxis: null; + provision: null; + subterhuman: null; + sunlit: null; + syncraniate: null; + teachment: null; + unmutinous: null; + unstoppable: null; +} + +export type RebeccaElement = Rebecca | number | string; + +export interface Rebecca { + Chirotherium: number; + catharticalness: number; + disdiapason: string; + homocerc: boolean; + nonbookish: null; +} + +export type Rhomboganoidei = number[] | Rebecca | string; + +export type Ruellia = boolean | Rebecca | string; + +export type School = number | { [key: string]: number } | null; + +export type Shakespearolater = number[] | number | string; + +export type Academe = number[] | number | { [key: string]: number }; + +export type Acquirable = (number | null)[] | { [key: string]: number }; + +export type Aerometry = boolean | number; + +export type Alexin = number[] | boolean; + +export type AlleviateElement = (number | null)[] | AlleviateClass; + +export interface AlleviateClass { + Hulsean: null; + apriori: null; + beggarer: null; + brokenheartedly: null; + debilitation: null; + frike: null; + gastrolith: null; + orthocentric: null; + petaly: null; + probudgeting: null; + reacquire: null; + scow: null; + shutoff: null; + subcontiguous: null; + suffumigate: null; + transformable: null; + uncoroneted: null; + unparking: null; + unvarnishedness: null; + wherewithal: null; +} + +export type Amaa = boolean | Rebecca | number; + +export type Ambassage = null[] | string; + +export interface Amphithyron { + Chirotherium?: number; + Juniperus?: number; + Nazirite?: number; + Those?: number; + akroasis?: number; + antiphonical?: number; + basebred?: number; + catharticalness?: number; + conductometric?: number; + disdiapason?: string; + ensilation?: number; + eyebolt?: number; + fistulated?: number; + heteropod?: number; + homocerc?: boolean; + labyrinthically?: number; + martyrization?: number; + mispolicy?: number; + multipara?: number; + nonbookish?: null; + possessorial?: number; + shamed?: number; + shelfworn?: number; + stagnum?: number; + undecimal?: number; +} + +export type AnkeeElement = number[] | AnkeeClass | number; + +export interface AnkeeClass { + Anomoean: null; + Naja: null; + barleyhood: null; + befriender: null; + brutishness: null; + cephalalgy: null; + cirurgian: null; + conventionally: null; + jackshay: null; + milammeter: null; + ombrological: null; + phonasthenia: null; + retrievableness: null; + snakily: null; + swot: null; + tartlet: null; + thiofuran: null; + tracheophone: null; + tuglike: null; + unscratchingly: null; +} + +export type Aphasia = number[] | number; + +export type Asprawl = number | string; + +export type Bedesman = boolean | number | string; + +export type Belard = number[] | Rebecca | number; + +export type Bocking = number[] | boolean | { [key: string]: number }; + +export type Brawlingly = null[] | { [key: string]: number | null }; + +export type Brookie = number[] | Rebecca; + +export type Bumboatman = null[] | null | string; + +export type Calaverite = number[] | string; + +export type Catallactic = null[] | boolean | { [key: string]: number }; + +export type Cemental = number[] | number | { [key: string]: number }; + +// Converts JSON strings to/from your types +// and asserts the results of JSON.parse at runtime +export class Convert { + public static toTopLevel(json: string): TopLevel { + return cast(JSON.parse(json), r("TopLevel")); + } + + public static topLevelToJson(value: TopLevel): string { + return JSON.stringify(uncast(value, r("TopLevel")), null, 2); + } +} + +function invalidValue(typ: any, val: any, key: any, parent: any = ''): never { + const prettyTyp = prettyTypeName(typ); + const parentText = parent ? ` on ${parent}` : ''; + const keyText = key ? ` for key "${key}"` : ''; + throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`); +} + +function prettyTypeName(typ: any): string { + if (Array.isArray(typ)) { + if (typ.length === 2 && typ[0] === undefined) { + return `an optional ${prettyTypeName(typ[1])}`; + } else { + return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`; + } + } else if (typeof typ === "object" && typ.literal !== undefined) { + return typ.literal; + } else { + return typeof typ; + } +} + +function jsonToJSProps(typ: any): any { + if (typ.jsonToJS === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ }); + typ.jsonToJS = map; + } + return typ.jsonToJS; +} + +function jsToJSONProps(typ: any): any { + if (typ.jsToJSON === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ }); + typ.jsToJSON = map; + } + return typ.jsToJSON; +} + +function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any { + function transformPrimitive(typ: string, val: any): any { + if (typeof typ === typeof val) return val; + return invalidValue(typ, val, key, parent); + } + + function transformUnion(typs: any[], val: any): any { + // val must validate against one typ in typs + const l = typs.length; + for (let i = 0; i < l; i++) { + const typ = typs[i]; + try { + return transform(val, typ, getProps); + } catch (_) {} + } + return invalidValue(typs, val, key, parent); + } + + function transformEnum(cases: string[], val: any): any { + if (cases.indexOf(val) !== -1) return val; + return invalidValue(cases.map(a => { return l(a); }), val, key, parent); + } + + function transformArray(typ: any, val: any): any { + // val must be an array with no invalid elements + if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent); + + return val.map(el => transform(el, typ, getProps)); + } + + function transformDate(val: any): any { + if (val === null) { + return null; + } + const d = new Date(val); + if (isNaN(d.valueOf())) { + return invalidValue(l("Date"), val, key, parent); + } + return d; + } + + function transformObject(props: { [k: string]: any }, additional: any, val: any): any { + if (val === null || typeof val !== "object" || Array.isArray(val)) { + return invalidValue(l(ref || "object"), val, key, parent); + } + const result: any = {}; + Object.getOwnPropertyNames(props).forEach(key => { + const prop = props[key]; + const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined; + result[prop.key] = transform(v, prop.typ, getProps, key, ref); + }); + Object.getOwnPropertyNames(val).forEach(key => { + if (!Object.prototype.hasOwnProperty.call(props, key)) { + result[key] = transform(val[key], additional, getProps, key, ref); + } + }); + return result; + } + + if (typ === "any") return val; + if (typ === null) { + if (val === null) return val; + return invalidValue(typ, val, key, parent); + } + if (typ === false) return invalidValue(typ, val, key, parent); + let ref: any = undefined; + while (typeof typ === "object" && typ.ref !== undefined) { + ref = typ.ref; + typ = typeMap[typ.ref]; + } + if (Array.isArray(typ)) return transformEnum(typ, val); + if (typeof typ === "object") { + return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) + : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) + : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val) + : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val) + : invalidValue(typ, val, key, parent); + } + // Numbers can be parsed by Date but shouldn't be. + if (typ === Date && typeof val !== "number") return transformDate(val); + return transformPrimitive(typ, val); +} + +function cast(val: any, typ: any): T { + return transform(val, typ, jsonToJSProps); +} + +function uncast(val: T, typ: any): any { + return transform(val, typ, jsToJSONProps); +} + +function l(typ: any) { + return { literal: typ }; +} + +function a(typ: any) { + return { arrayItems: typ }; +} + +function i(typ: any) { + return { integer: typ }; +} + +function p(pattern: any) { + return { pattern }; +} + +function s(typ: any, min: any, max: any) { + return { string: typ, min, max }; +} + +function n(typ: any, min: any, max: any) { + return { number: typ, min, max }; +} + +function u(...typs: any[]) { + return { unionMembers: typs }; +} + +function o(props: any[], additional: any) { + return { props, additional }; +} + +function m(additional: any) { + const props: any[] = []; + return { props, additional }; +} + +function r(name: string) { + return { ref: name }; +} + +const typeMap: any = { + "TopLevel": o([ + { json: "Abranchiata", js: "Abranchiata", typ: a(u(a(i(0)), i(0), null)) }, + { json: "Andriana", js: "Andriana", typ: a(u(null, "")) }, + { json: "Ansarie", js: "Ansarie", typ: a(u(a(i(0)), r("AnsarieClass"), null)) }, + { json: "Chytridiaceae", js: "Chytridiaceae", typ: a(u(true, r("ChytridiaceaeClass"), null)) }, + { json: "Discordia", js: "Discordia", typ: a(u(a(i(0)), r("DiscordiaClass"))) }, + { json: "Endomyces", js: "Endomyces", typ: a(u(i(0), "")) }, + { json: "Epinephelidae", js: "Epinephelidae", typ: a(u(true, i(0), "")) }, + { json: "Eupatorium", js: "Eupatorium", typ: a(u(a(null), m(i(0)))) }, + { json: "Gryphosaurus", js: "Gryphosaurus", typ: a(u(a(i(0)), r("GryphosaurusClass"), "")) }, + { json: "Koryak", js: "Koryak", typ: a(u(m(u(i(0), null)), "")) }, + { json: "Lavinia", js: "Lavinia", typ: a(u(r("LaviniaClass"), "")) }, + { json: "Oskar", js: "Oskar", typ: a(u(a(i(0)), r("OskarClass"))) }, + { json: "Rebecca", js: "Rebecca", typ: a(u(r("Rebecca"), i(0), "")) }, + { json: "Rhomboganoidei", js: "Rhomboganoidei", typ: a(u(a(i(0)), r("Rebecca"), "")) }, + { json: "Rigsmal", js: "Rigsmal", typ: true }, + { json: "Ruellia", js: "Ruellia", typ: a(u(true, r("Rebecca"), "")) }, + { json: "School", js: "School", typ: a(u(i(0), m(i(0)), null)) }, + { json: "Shakespearolater", js: "Shakespearolater", typ: a(u(a(i(0)), 3.14, "")) }, + { json: "Svan", js: "Svan", typ: a(3.14) }, + { json: "Wayao", js: "Wayao", typ: m(3.14) }, + { json: "academe", js: "academe", typ: a(u(a(i(0)), i(0), m(i(0)))) }, + { json: "acquirable", js: "acquirable", typ: a(u(a(u(i(0), null)), m(i(0)))) }, + { json: "aerometry", js: "aerometry", typ: a(u(true, 3.14)) }, + { json: "alexin", js: "alexin", typ: a(u(a(i(0)), true)) }, + { json: "alleviate", js: "alleviate", typ: a(u(a(u(i(0), null)), r("AlleviateClass"))) }, + { json: "amaas", js: "amaas", typ: a(u(true, r("Rebecca"), i(0))) }, + { json: "ambassage", js: "ambassage", typ: a(u(a(null), "")) }, + { json: "amphithyron", js: "amphithyron", typ: a(u(r("Amphithyron"), null)) }, + { json: "ankee", js: "ankee", typ: a(u(a(i(0)), r("AnkeeClass"), i(0))) }, + { json: "annihilator", js: "annihilator", typ: a(u(m(u(i(0), null)), null)) }, + { json: "annulose", js: "annulose", typ: null }, + { json: "aphasia", js: "aphasia", typ: a(u(a(i(0)), i(0))) }, + { json: "asprawl", js: "asprawl", typ: a(u(3.14, "")) }, + { json: "attractive", js: "attractive", typ: a(u(true, null)) }, + { json: "barksome", js: "barksome", typ: m(i(0)) }, + { json: "bedesman", js: "bedesman", typ: a(u(true, 3.14, "")) }, + { json: "belard", js: "belard", typ: a(u(a(i(0)), r("Rebecca"), 3.14)) }, + { json: "bocking", js: "bocking", typ: a(u(a(i(0)), true, m(i(0)))) }, + { json: "brawlingly", js: "brawlingly", typ: a(u(a(null), m(u(i(0), null)))) }, + { json: "brookie", js: "brookie", typ: a(u(a(i(0)), r("Rebecca"))) }, + { json: "bumboatman", js: "bumboatman", typ: a(u(a(null), null, "")) }, + { json: "bystreet", js: "bystreet", typ: a(null) }, + { json: "calaverite", js: "calaverite", typ: a(u(a(i(0)), "")) }, + { json: "catallactic", js: "catallactic", typ: a(u(a(null), true, m(i(0)))) }, + { json: "cemental", js: "cemental", typ: a(u(a(i(0)), 3.14, m(i(0)))) }, + ], false), + "AnsarieClass": o([ + { json: "Alida", js: "Alida", typ: null }, + { json: "Ictonyx", js: "Ictonyx", typ: null }, + { json: "Ramist", js: "Ramist", typ: null }, + { json: "accension", js: "accension", typ: null }, + { json: "asteria", js: "asteria", typ: null }, + { json: "beriberic", js: "beriberic", typ: null }, + { json: "edgebone", js: "edgebone", typ: null }, + { json: "gastrodialysis", js: "gastrodialysis", typ: null }, + { json: "geographic", js: "geographic", typ: null }, + { json: "metrocele", js: "metrocele", typ: null }, + { json: "misgraft", js: "misgraft", typ: null }, + { json: "monteith", js: "monteith", typ: null }, + { json: "notcher", js: "notcher", typ: null }, + { json: "prorestriction", js: "prorestriction", typ: null }, + { json: "throatlet", js: "throatlet", typ: null }, + { json: "unfair", js: "unfair", typ: null }, + { json: "unsynonymous", js: "unsynonymous", typ: null }, + { json: "water", js: "water", typ: null }, + { json: "zestfully", js: "zestfully", typ: null }, + { json: "zincic", js: "zincic", typ: null }, + ], false), + "ChytridiaceaeClass": o([ + { json: "Batidaceae", js: "Batidaceae", typ: null }, + { json: "Brechites", js: "Brechites", typ: null }, + { json: "Emery", js: "Emery", typ: null }, + { json: "Narraganset", js: "Narraganset", typ: null }, + { json: "codespairer", js: "codespairer", typ: null }, + { json: "enervative", js: "enervative", typ: null }, + { json: "excriminate", js: "excriminate", typ: null }, + { json: "goshenite", js: "goshenite", typ: null }, + { json: "grime", js: "grime", typ: null }, + { json: "gritten", js: "gritten", typ: null }, + { json: "hectorly", js: "hectorly", typ: null }, + { json: "intermediation", js: "intermediation", typ: null }, + { json: "meeterly", js: "meeterly", typ: null }, + { json: "onymatic", js: "onymatic", typ: null }, + { json: "paddlecock", js: "paddlecock", typ: null }, + { json: "thana", js: "thana", typ: null }, + { json: "thornily", js: "thornily", typ: null }, + { json: "uckia", js: "uckia", typ: null }, + { json: "unmettle", js: "unmettle", typ: null }, + { json: "vorticellid", js: "vorticellid", typ: null }, + ], false), + "DiscordiaClass": o([ + { json: "Altaic", js: "Altaic", typ: u(undefined, i(0)) }, + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Patarin", js: "Patarin", typ: u(undefined, i(0)) }, + { json: "amoristic", js: "amoristic", typ: u(undefined, i(0)) }, + { json: "blennophthalmia", js: "blennophthalmia", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "disciplinability", js: "disciplinability", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "goofer", js: "goofer", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "laryngograph", js: "laryngograph", typ: u(undefined, i(0)) }, + { json: "leucitis", js: "leucitis", typ: u(undefined, i(0)) }, + { json: "lymphocyst", js: "lymphocyst", typ: u(undefined, i(0)) }, + { json: "microcosmology", js: "microcosmology", typ: u(undefined, i(0)) }, + { json: "nauseation", js: "nauseation", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "preliberal", js: "preliberal", typ: u(undefined, i(0)) }, + { json: "prettifier", js: "prettifier", typ: u(undefined, i(0)) }, + { json: "rangework", js: "rangework", typ: u(undefined, i(0)) }, + { json: "redient", js: "redient", typ: u(undefined, i(0)) }, + { json: "subfusiform", js: "subfusiform", typ: u(undefined, i(0)) }, + { json: "suicidical", js: "suicidical", typ: u(undefined, i(0)) }, + { json: "swow", js: "swow", typ: u(undefined, i(0)) }, + { json: "wastrel", js: "wastrel", typ: u(undefined, i(0)) }, + { json: "wingle", js: "wingle", typ: u(undefined, i(0)) }, + ], false), + "GryphosaurusClass": o([ + { json: "Burushaski", js: "Burushaski", typ: null }, + { json: "Tahami", js: "Tahami", typ: null }, + { json: "amissibility", js: "amissibility", typ: null }, + { json: "citronin", js: "citronin", typ: null }, + { json: "coplaintiff", js: "coplaintiff", typ: null }, + { json: "disquisitionary", js: "disquisitionary", typ: null }, + { json: "enoplan", js: "enoplan", typ: null }, + { json: "faintness", js: "faintness", typ: null }, + { json: "hebetomy", js: "hebetomy", typ: null }, + { json: "islandry", js: "islandry", typ: null }, + { json: "lameduck", js: "lameduck", typ: null }, + { json: "overbattle", js: "overbattle", typ: null }, + { json: "overinterested", js: "overinterested", typ: null }, + { json: "phrenologic", js: "phrenologic", typ: null }, + { json: "rainband", js: "rainband", typ: null }, + { json: "shiningly", js: "shiningly", typ: null }, + { json: "stamineous", js: "stamineous", typ: null }, + { json: "subscapularis", js: "subscapularis", typ: null }, + { json: "undaubed", js: "undaubed", typ: null }, + { json: "underntime", js: "underntime", typ: null }, + ], false), + "LaviniaClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Tacana", js: "Tacana", typ: u(undefined, i(0)) }, + { json: "agitable", js: "agitable", typ: u(undefined, i(0)) }, + { json: "asininity", js: "asininity", typ: u(undefined, i(0)) }, + { json: "benefiter", js: "benefiter", typ: u(undefined, i(0)) }, + { json: "bronzelike", js: "bronzelike", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "cholesteatomatous", js: "cholesteatomatous", typ: u(undefined, i(0)) }, + { json: "deprivement", js: "deprivement", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "flippantness", js: "flippantness", typ: u(undefined, i(0)) }, + { json: "fogproof", js: "fogproof", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "merrymeeting", js: "merrymeeting", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "overcareful", js: "overcareful", typ: u(undefined, i(0)) }, + { json: "panaris", js: "panaris", typ: u(undefined, i(0)) }, + { json: "preacceptance", js: "preacceptance", typ: u(undefined, i(0)) }, + { json: "quinoxaline", js: "quinoxaline", typ: u(undefined, i(0)) }, + { json: "sig", js: "sig", typ: u(undefined, i(0)) }, + { json: "superconfusion", js: "superconfusion", typ: u(undefined, i(0)) }, + { json: "tillotter", js: "tillotter", typ: u(undefined, i(0)) }, + { json: "tranquillize", js: "tranquillize", typ: u(undefined, i(0)) }, + { json: "unquestionable", js: "unquestionable", typ: u(undefined, i(0)) }, + { json: "uproute", js: "uproute", typ: u(undefined, i(0)) }, + ], false), + "OskarClass": o([ + { json: "Acrobates", js: "Acrobates", typ: null }, + { json: "Cayuga", js: "Cayuga", typ: null }, + { json: "Netherlandish", js: "Netherlandish", typ: null }, + { json: "beanshooter", js: "beanshooter", typ: null }, + { json: "bearhound", js: "bearhound", typ: null }, + { json: "guarneri", js: "guarneri", typ: null }, + { json: "hypochondriacism", js: "hypochondriacism", typ: null }, + { json: "indication", js: "indication", typ: null }, + { json: "jaculative", js: "jaculative", typ: null }, + { json: "nagana", js: "nagana", typ: null }, + { json: "noctivagous", js: "noctivagous", typ: null }, + { json: "nonphysiological", js: "nonphysiological", typ: null }, + { json: "praxis", js: "praxis", typ: null }, + { json: "provision", js: "provision", typ: null }, + { json: "subterhuman", js: "subterhuman", typ: null }, + { json: "sunlit", js: "sunlit", typ: null }, + { json: "syncraniate", js: "syncraniate", typ: null }, + { json: "teachment", js: "teachment", typ: null }, + { json: "unmutinous", js: "unmutinous", typ: null }, + { json: "unstoppable", js: "unstoppable", typ: null }, + ], false), + "Rebecca": o([ + { json: "Chirotherium", js: "Chirotherium", typ: i(0) }, + { json: "catharticalness", js: "catharticalness", typ: 3.14 }, + { json: "disdiapason", js: "disdiapason", typ: "" }, + { json: "homocerc", js: "homocerc", typ: true }, + { json: "nonbookish", js: "nonbookish", typ: null }, + ], false), + "AlleviateClass": o([ + { json: "Hulsean", js: "Hulsean", typ: null }, + { json: "apriori", js: "apriori", typ: null }, + { json: "beggarer", js: "beggarer", typ: null }, + { json: "brokenheartedly", js: "brokenheartedly", typ: null }, + { json: "debilitation", js: "debilitation", typ: null }, + { json: "frike", js: "frike", typ: null }, + { json: "gastrolith", js: "gastrolith", typ: null }, + { json: "orthocentric", js: "orthocentric", typ: null }, + { json: "petaly", js: "petaly", typ: null }, + { json: "probudgeting", js: "probudgeting", typ: null }, + { json: "reacquire", js: "reacquire", typ: null }, + { json: "scow", js: "scow", typ: null }, + { json: "shutoff", js: "shutoff", typ: null }, + { json: "subcontiguous", js: "subcontiguous", typ: null }, + { json: "suffumigate", js: "suffumigate", typ: null }, + { json: "transformable", js: "transformable", typ: null }, + { json: "uncoroneted", js: "uncoroneted", typ: null }, + { json: "unparking", js: "unparking", typ: null }, + { json: "unvarnishedness", js: "unvarnishedness", typ: null }, + { json: "wherewithal", js: "wherewithal", typ: null }, + ], false), + "Amphithyron": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Juniperus", js: "Juniperus", typ: u(undefined, i(0)) }, + { json: "Nazirite", js: "Nazirite", typ: u(undefined, i(0)) }, + { json: "Those", js: "Those", typ: u(undefined, i(0)) }, + { json: "akroasis", js: "akroasis", typ: u(undefined, i(0)) }, + { json: "antiphonical", js: "antiphonical", typ: u(undefined, i(0)) }, + { json: "basebred", js: "basebred", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "conductometric", js: "conductometric", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "ensilation", js: "ensilation", typ: u(undefined, i(0)) }, + { json: "eyebolt", js: "eyebolt", typ: u(undefined, i(0)) }, + { json: "fistulated", js: "fistulated", typ: u(undefined, i(0)) }, + { json: "heteropod", js: "heteropod", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "labyrinthically", js: "labyrinthically", typ: u(undefined, i(0)) }, + { json: "martyrization", js: "martyrization", typ: u(undefined, i(0)) }, + { json: "mispolicy", js: "mispolicy", typ: u(undefined, i(0)) }, + { json: "multipara", js: "multipara", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "possessorial", js: "possessorial", typ: u(undefined, i(0)) }, + { json: "shamed", js: "shamed", typ: u(undefined, i(0)) }, + { json: "shelfworn", js: "shelfworn", typ: u(undefined, i(0)) }, + { json: "stagnum", js: "stagnum", typ: u(undefined, i(0)) }, + { json: "undecimal", js: "undecimal", typ: u(undefined, i(0)) }, + ], false), + "AnkeeClass": o([ + { json: "Anomoean", js: "Anomoean", typ: null }, + { json: "Naja", js: "Naja", typ: null }, + { json: "barleyhood", js: "barleyhood", typ: null }, + { json: "befriender", js: "befriender", typ: null }, + { json: "brutishness", js: "brutishness", typ: null }, + { json: "cephalalgy", js: "cephalalgy", typ: null }, + { json: "cirurgian", js: "cirurgian", typ: null }, + { json: "conventionally", js: "conventionally", typ: null }, + { json: "jackshay", js: "jackshay", typ: null }, + { json: "milammeter", js: "milammeter", typ: null }, + { json: "ombrological", js: "ombrological", typ: null }, + { json: "phonasthenia", js: "phonasthenia", typ: null }, + { json: "retrievableness", js: "retrievableness", typ: null }, + { json: "snakily", js: "snakily", typ: null }, + { json: "swot", js: "swot", typ: null }, + { json: "tartlet", js: "tartlet", typ: null }, + { json: "thiofuran", js: "thiofuran", typ: null }, + { json: "tracheophone", js: "tracheophone", typ: null }, + { json: "tuglike", js: "tuglike", typ: null }, + { json: "unscratchingly", js: "unscratchingly", typ: null }, + ], false), +}; diff --git a/head/typescript/test/inputs/json/priority/combinations2.json/prefer-types-true--df33e18681f9/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations2.json/prefer-types-true--df33e18681f9/TopLevel.ts new file mode 100644 index 0000000..cdd0ff3 --- /dev/null +++ b/head/typescript/test/inputs/json/priority/combinations2.json/prefer-types-true--df33e18681f9/TopLevel.ts @@ -0,0 +1,812 @@ +// To parse this data: +// +// import { Convert, TopLevel } from "./TopLevel"; +// +// const topLevel = Convert.toTopLevel(json); +// +// These functions will throw an error if the JSON doesn't +// match the expected interface, even if the JSON is valid. + +export type TopLevel = { + Abranchiata: Abranchiata[]; + Andriana: (null | string)[]; + Ansarie: AnsarieElement[]; + Chytridiaceae: ChytridiaceaeElement[]; + Discordia: DiscordiaElement[]; + Endomyces: Endomyce[]; + Epinephelidae: Epinephelidae[]; + Eupatorium: Eupatorium[]; + Gryphosaurus: GryphosaurusElement[]; + Koryak: Koryak[]; + Lavinia: LaviniaElement[]; + Oskar: OskarElement[]; + Rebecca: RebeccaElement[]; + Rhomboganoidei: Rhomboganoidei[]; + Rigsmal: boolean; + Ruellia: Ruellia[]; + School: School[]; + Shakespearolater: Shakespearolater[]; + Svan: number[]; + Wayao: { [key: string]: number }; + academe: Academe[]; + acquirable: Acquirable[]; + aerometry: Aerometry[]; + alexin: Alexin[]; + alleviate: AlleviateElement[]; + amaas: Amaa[]; + ambassage: Ambassage[]; + amphithyron: (Amphithyron | null)[]; + ankee: AnkeeElement[]; + annihilator: ({ [key: string]: number | null } | null)[]; + annulose: null; + aphasia: Aphasia[]; + asprawl: Asprawl[]; + attractive: (boolean | null)[]; + barksome: { [key: string]: number }; + bedesman: Bedesman[]; + belard: Belard[]; + bocking: Bocking[]; + brawlingly: Brawlingly[]; + brookie: Brookie[]; + bumboatman: Bumboatman[]; + bystreet: null[]; + calaverite: Calaverite[]; + catallactic: Catallactic[]; + cemental: Cemental[]; +} + +export type Abranchiata = number[] | number | null; + +export type AnsarieElement = number[] | AnsarieClass | null; + +export type AnsarieClass = { + Alida: null; + Ictonyx: null; + Ramist: null; + accension: null; + asteria: null; + beriberic: null; + edgebone: null; + gastrodialysis: null; + geographic: null; + metrocele: null; + misgraft: null; + monteith: null; + notcher: null; + prorestriction: null; + throatlet: null; + unfair: null; + unsynonymous: null; + water: null; + zestfully: null; + zincic: null; +} + +export type ChytridiaceaeElement = boolean | ChytridiaceaeClass | null; + +export type ChytridiaceaeClass = { + Batidaceae: null; + Brechites: null; + Emery: null; + Narraganset: null; + codespairer: null; + enervative: null; + excriminate: null; + goshenite: null; + grime: null; + gritten: null; + hectorly: null; + intermediation: null; + meeterly: null; + onymatic: null; + paddlecock: null; + thana: null; + thornily: null; + uckia: null; + unmettle: null; + vorticellid: null; +} + +export type DiscordiaElement = number[] | DiscordiaClass; + +export type DiscordiaClass = { + Altaic?: number; + Chirotherium?: number; + Patarin?: number; + amoristic?: number; + blennophthalmia?: number; + catharticalness?: number; + disciplinability?: number; + disdiapason?: string; + goofer?: number; + homocerc?: boolean; + laryngograph?: number; + leucitis?: number; + lymphocyst?: number; + microcosmology?: number; + nauseation?: number; + nonbookish?: null; + preliberal?: number; + prettifier?: number; + rangework?: number; + redient?: number; + subfusiform?: number; + suicidical?: number; + swow?: number; + wastrel?: number; + wingle?: number; +} + +export type Endomyce = number | string; + +export type Epinephelidae = boolean | number | string; + +export type Eupatorium = null[] | { [key: string]: number }; + +export type GryphosaurusElement = number[] | GryphosaurusClass | string; + +export type GryphosaurusClass = { + Burushaski: null; + Tahami: null; + amissibility: null; + citronin: null; + coplaintiff: null; + disquisitionary: null; + enoplan: null; + faintness: null; + hebetomy: null; + islandry: null; + lameduck: null; + overbattle: null; + overinterested: null; + phrenologic: null; + rainband: null; + shiningly: null; + stamineous: null; + subscapularis: null; + undaubed: null; + underntime: null; +} + +export type Koryak = { [key: string]: number | null } | string; + +export type LaviniaElement = LaviniaClass | string; + +export type LaviniaClass = { + Chirotherium?: number; + Tacana?: number; + agitable?: number; + asininity?: number; + benefiter?: number; + bronzelike?: number; + catharticalness?: number; + cholesteatomatous?: number; + deprivement?: number; + disdiapason?: string; + flippantness?: number; + fogproof?: number; + homocerc?: boolean; + merrymeeting?: number; + nonbookish?: null; + overcareful?: number; + panaris?: number; + preacceptance?: number; + quinoxaline?: number; + sig?: number; + superconfusion?: number; + tillotter?: number; + tranquillize?: number; + unquestionable?: number; + uproute?: number; +} + +export type OskarElement = number[] | OskarClass; + +export type OskarClass = { + Acrobates: null; + Cayuga: null; + Netherlandish: null; + beanshooter: null; + bearhound: null; + guarneri: null; + hypochondriacism: null; + indication: null; + jaculative: null; + nagana: null; + noctivagous: null; + nonphysiological: null; + praxis: null; + provision: null; + subterhuman: null; + sunlit: null; + syncraniate: null; + teachment: null; + unmutinous: null; + unstoppable: null; +} + +export type RebeccaElement = Rebecca | number | string; + +export type Rebecca = { + Chirotherium: number; + catharticalness: number; + disdiapason: string; + homocerc: boolean; + nonbookish: null; +} + +export type Rhomboganoidei = number[] | Rebecca | string; + +export type Ruellia = boolean | Rebecca | string; + +export type School = number | { [key: string]: number } | null; + +export type Shakespearolater = number[] | number | string; + +export type Academe = number[] | number | { [key: string]: number }; + +export type Acquirable = (number | null)[] | { [key: string]: number }; + +export type Aerometry = boolean | number; + +export type Alexin = number[] | boolean; + +export type AlleviateElement = (number | null)[] | AlleviateClass; + +export type AlleviateClass = { + Hulsean: null; + apriori: null; + beggarer: null; + brokenheartedly: null; + debilitation: null; + frike: null; + gastrolith: null; + orthocentric: null; + petaly: null; + probudgeting: null; + reacquire: null; + scow: null; + shutoff: null; + subcontiguous: null; + suffumigate: null; + transformable: null; + uncoroneted: null; + unparking: null; + unvarnishedness: null; + wherewithal: null; +} + +export type Amaa = boolean | Rebecca | number; + +export type Ambassage = null[] | string; + +export type Amphithyron = { + Chirotherium?: number; + Juniperus?: number; + Nazirite?: number; + Those?: number; + akroasis?: number; + antiphonical?: number; + basebred?: number; + catharticalness?: number; + conductometric?: number; + disdiapason?: string; + ensilation?: number; + eyebolt?: number; + fistulated?: number; + heteropod?: number; + homocerc?: boolean; + labyrinthically?: number; + martyrization?: number; + mispolicy?: number; + multipara?: number; + nonbookish?: null; + possessorial?: number; + shamed?: number; + shelfworn?: number; + stagnum?: number; + undecimal?: number; +} + +export type AnkeeElement = number[] | AnkeeClass | number; + +export type AnkeeClass = { + Anomoean: null; + Naja: null; + barleyhood: null; + befriender: null; + brutishness: null; + cephalalgy: null; + cirurgian: null; + conventionally: null; + jackshay: null; + milammeter: null; + ombrological: null; + phonasthenia: null; + retrievableness: null; + snakily: null; + swot: null; + tartlet: null; + thiofuran: null; + tracheophone: null; + tuglike: null; + unscratchingly: null; +} + +export type Aphasia = number[] | number; + +export type Asprawl = number | string; + +export type Bedesman = boolean | number | string; + +export type Belard = number[] | Rebecca | number; + +export type Bocking = number[] | boolean | { [key: string]: number }; + +export type Brawlingly = null[] | { [key: string]: number | null }; + +export type Brookie = number[] | Rebecca; + +export type Bumboatman = null[] | null | string; + +export type Calaverite = number[] | string; + +export type Catallactic = null[] | boolean | { [key: string]: number }; + +export type Cemental = number[] | number | { [key: string]: number }; + +// Converts JSON strings to/from your types +// and asserts the results of JSON.parse at runtime +export class Convert { + public static toTopLevel(json: string): TopLevel { + return cast(JSON.parse(json), r("TopLevel")); + } + + public static topLevelToJson(value: TopLevel): string { + return JSON.stringify(uncast(value, r("TopLevel")), null, 2); + } +} + +function invalidValue(typ: any, val: any, key: any, parent: any = ''): never { + const prettyTyp = prettyTypeName(typ); + const parentText = parent ? ` on ${parent}` : ''; + const keyText = key ? ` for key "${key}"` : ''; + throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`); +} + +function prettyTypeName(typ: any): string { + if (Array.isArray(typ)) { + if (typ.length === 2 && typ[0] === undefined) { + return `an optional ${prettyTypeName(typ[1])}`; + } else { + return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`; + } + } else if (typeof typ === "object" && typ.literal !== undefined) { + return typ.literal; + } else { + return typeof typ; + } +} + +function jsonToJSProps(typ: any): any { + if (typ.jsonToJS === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ }); + typ.jsonToJS = map; + } + return typ.jsonToJS; +} + +function jsToJSONProps(typ: any): any { + if (typ.jsToJSON === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ }); + typ.jsToJSON = map; + } + return typ.jsToJSON; +} + +function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any { + function transformPrimitive(typ: string, val: any): any { + if (typeof typ === typeof val) return val; + return invalidValue(typ, val, key, parent); + } + + function transformUnion(typs: any[], val: any): any { + // val must validate against one typ in typs + const l = typs.length; + for (let i = 0; i < l; i++) { + const typ = typs[i]; + try { + return transform(val, typ, getProps); + } catch (_) {} + } + return invalidValue(typs, val, key, parent); + } + + function transformEnum(cases: string[], val: any): any { + if (cases.indexOf(val) !== -1) return val; + return invalidValue(cases.map(a => { return l(a); }), val, key, parent); + } + + function transformArray(typ: any, val: any): any { + // val must be an array with no invalid elements + if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent); + + return val.map(el => transform(el, typ, getProps)); + } + + function transformDate(val: any): any { + if (val === null) { + return null; + } + const d = new Date(val); + if (isNaN(d.valueOf())) { + return invalidValue(l("Date"), val, key, parent); + } + return d; + } + + function transformObject(props: { [k: string]: any }, additional: any, val: any): any { + if (val === null || typeof val !== "object" || Array.isArray(val)) { + return invalidValue(l(ref || "object"), val, key, parent); + } + const result: any = {}; + Object.getOwnPropertyNames(props).forEach(key => { + const prop = props[key]; + const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined; + result[prop.key] = transform(v, prop.typ, getProps, key, ref); + }); + Object.getOwnPropertyNames(val).forEach(key => { + if (!Object.prototype.hasOwnProperty.call(props, key)) { + result[key] = transform(val[key], additional, getProps, key, ref); + } + }); + return result; + } + + if (typ === "any") return val; + if (typ === null) { + if (val === null) return val; + return invalidValue(typ, val, key, parent); + } + if (typ === false) return invalidValue(typ, val, key, parent); + let ref: any = undefined; + while (typeof typ === "object" && typ.ref !== undefined) { + ref = typ.ref; + typ = typeMap[typ.ref]; + } + if (Array.isArray(typ)) return transformEnum(typ, val); + if (typeof typ === "object") { + return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) + : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) + : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val) + : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val) + : invalidValue(typ, val, key, parent); + } + // Numbers can be parsed by Date but shouldn't be. + if (typ === Date && typeof val !== "number") return transformDate(val); + return transformPrimitive(typ, val); +} + +function cast(val: any, typ: any): T { + return transform(val, typ, jsonToJSProps); +} + +function uncast(val: T, typ: any): any { + return transform(val, typ, jsToJSONProps); +} + +function l(typ: any) { + return { literal: typ }; +} + +function a(typ: any) { + return { arrayItems: typ }; +} + +function i(typ: any) { + return { integer: typ }; +} + +function p(pattern: any) { + return { pattern }; +} + +function s(typ: any, min: any, max: any) { + return { string: typ, min, max }; +} + +function n(typ: any, min: any, max: any) { + return { number: typ, min, max }; +} + +function u(...typs: any[]) { + return { unionMembers: typs }; +} + +function o(props: any[], additional: any) { + return { props, additional }; +} + +function m(additional: any) { + const props: any[] = []; + return { props, additional }; +} + +function r(name: string) { + return { ref: name }; +} + +const typeMap: any = { + "TopLevel": o([ + { json: "Abranchiata", js: "Abranchiata", typ: a(u(a(i(0)), i(0), null)) }, + { json: "Andriana", js: "Andriana", typ: a(u(null, "")) }, + { json: "Ansarie", js: "Ansarie", typ: a(u(a(i(0)), r("AnsarieClass"), null)) }, + { json: "Chytridiaceae", js: "Chytridiaceae", typ: a(u(true, r("ChytridiaceaeClass"), null)) }, + { json: "Discordia", js: "Discordia", typ: a(u(a(i(0)), r("DiscordiaClass"))) }, + { json: "Endomyces", js: "Endomyces", typ: a(u(i(0), "")) }, + { json: "Epinephelidae", js: "Epinephelidae", typ: a(u(true, i(0), "")) }, + { json: "Eupatorium", js: "Eupatorium", typ: a(u(a(null), m(i(0)))) }, + { json: "Gryphosaurus", js: "Gryphosaurus", typ: a(u(a(i(0)), r("GryphosaurusClass"), "")) }, + { json: "Koryak", js: "Koryak", typ: a(u(m(u(i(0), null)), "")) }, + { json: "Lavinia", js: "Lavinia", typ: a(u(r("LaviniaClass"), "")) }, + { json: "Oskar", js: "Oskar", typ: a(u(a(i(0)), r("OskarClass"))) }, + { json: "Rebecca", js: "Rebecca", typ: a(u(r("Rebecca"), i(0), "")) }, + { json: "Rhomboganoidei", js: "Rhomboganoidei", typ: a(u(a(i(0)), r("Rebecca"), "")) }, + { json: "Rigsmal", js: "Rigsmal", typ: true }, + { json: "Ruellia", js: "Ruellia", typ: a(u(true, r("Rebecca"), "")) }, + { json: "School", js: "School", typ: a(u(i(0), m(i(0)), null)) }, + { json: "Shakespearolater", js: "Shakespearolater", typ: a(u(a(i(0)), 3.14, "")) }, + { json: "Svan", js: "Svan", typ: a(3.14) }, + { json: "Wayao", js: "Wayao", typ: m(3.14) }, + { json: "academe", js: "academe", typ: a(u(a(i(0)), i(0), m(i(0)))) }, + { json: "acquirable", js: "acquirable", typ: a(u(a(u(i(0), null)), m(i(0)))) }, + { json: "aerometry", js: "aerometry", typ: a(u(true, 3.14)) }, + { json: "alexin", js: "alexin", typ: a(u(a(i(0)), true)) }, + { json: "alleviate", js: "alleviate", typ: a(u(a(u(i(0), null)), r("AlleviateClass"))) }, + { json: "amaas", js: "amaas", typ: a(u(true, r("Rebecca"), i(0))) }, + { json: "ambassage", js: "ambassage", typ: a(u(a(null), "")) }, + { json: "amphithyron", js: "amphithyron", typ: a(u(r("Amphithyron"), null)) }, + { json: "ankee", js: "ankee", typ: a(u(a(i(0)), r("AnkeeClass"), i(0))) }, + { json: "annihilator", js: "annihilator", typ: a(u(m(u(i(0), null)), null)) }, + { json: "annulose", js: "annulose", typ: null }, + { json: "aphasia", js: "aphasia", typ: a(u(a(i(0)), i(0))) }, + { json: "asprawl", js: "asprawl", typ: a(u(3.14, "")) }, + { json: "attractive", js: "attractive", typ: a(u(true, null)) }, + { json: "barksome", js: "barksome", typ: m(i(0)) }, + { json: "bedesman", js: "bedesman", typ: a(u(true, 3.14, "")) }, + { json: "belard", js: "belard", typ: a(u(a(i(0)), r("Rebecca"), 3.14)) }, + { json: "bocking", js: "bocking", typ: a(u(a(i(0)), true, m(i(0)))) }, + { json: "brawlingly", js: "brawlingly", typ: a(u(a(null), m(u(i(0), null)))) }, + { json: "brookie", js: "brookie", typ: a(u(a(i(0)), r("Rebecca"))) }, + { json: "bumboatman", js: "bumboatman", typ: a(u(a(null), null, "")) }, + { json: "bystreet", js: "bystreet", typ: a(null) }, + { json: "calaverite", js: "calaverite", typ: a(u(a(i(0)), "")) }, + { json: "catallactic", js: "catallactic", typ: a(u(a(null), true, m(i(0)))) }, + { json: "cemental", js: "cemental", typ: a(u(a(i(0)), 3.14, m(i(0)))) }, + ], false), + "AnsarieClass": o([ + { json: "Alida", js: "Alida", typ: null }, + { json: "Ictonyx", js: "Ictonyx", typ: null }, + { json: "Ramist", js: "Ramist", typ: null }, + { json: "accension", js: "accension", typ: null }, + { json: "asteria", js: "asteria", typ: null }, + { json: "beriberic", js: "beriberic", typ: null }, + { json: "edgebone", js: "edgebone", typ: null }, + { json: "gastrodialysis", js: "gastrodialysis", typ: null }, + { json: "geographic", js: "geographic", typ: null }, + { json: "metrocele", js: "metrocele", typ: null }, + { json: "misgraft", js: "misgraft", typ: null }, + { json: "monteith", js: "monteith", typ: null }, + { json: "notcher", js: "notcher", typ: null }, + { json: "prorestriction", js: "prorestriction", typ: null }, + { json: "throatlet", js: "throatlet", typ: null }, + { json: "unfair", js: "unfair", typ: null }, + { json: "unsynonymous", js: "unsynonymous", typ: null }, + { json: "water", js: "water", typ: null }, + { json: "zestfully", js: "zestfully", typ: null }, + { json: "zincic", js: "zincic", typ: null }, + ], false), + "ChytridiaceaeClass": o([ + { json: "Batidaceae", js: "Batidaceae", typ: null }, + { json: "Brechites", js: "Brechites", typ: null }, + { json: "Emery", js: "Emery", typ: null }, + { json: "Narraganset", js: "Narraganset", typ: null }, + { json: "codespairer", js: "codespairer", typ: null }, + { json: "enervative", js: "enervative", typ: null }, + { json: "excriminate", js: "excriminate", typ: null }, + { json: "goshenite", js: "goshenite", typ: null }, + { json: "grime", js: "grime", typ: null }, + { json: "gritten", js: "gritten", typ: null }, + { json: "hectorly", js: "hectorly", typ: null }, + { json: "intermediation", js: "intermediation", typ: null }, + { json: "meeterly", js: "meeterly", typ: null }, + { json: "onymatic", js: "onymatic", typ: null }, + { json: "paddlecock", js: "paddlecock", typ: null }, + { json: "thana", js: "thana", typ: null }, + { json: "thornily", js: "thornily", typ: null }, + { json: "uckia", js: "uckia", typ: null }, + { json: "unmettle", js: "unmettle", typ: null }, + { json: "vorticellid", js: "vorticellid", typ: null }, + ], false), + "DiscordiaClass": o([ + { json: "Altaic", js: "Altaic", typ: u(undefined, i(0)) }, + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Patarin", js: "Patarin", typ: u(undefined, i(0)) }, + { json: "amoristic", js: "amoristic", typ: u(undefined, i(0)) }, + { json: "blennophthalmia", js: "blennophthalmia", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "disciplinability", js: "disciplinability", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "goofer", js: "goofer", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "laryngograph", js: "laryngograph", typ: u(undefined, i(0)) }, + { json: "leucitis", js: "leucitis", typ: u(undefined, i(0)) }, + { json: "lymphocyst", js: "lymphocyst", typ: u(undefined, i(0)) }, + { json: "microcosmology", js: "microcosmology", typ: u(undefined, i(0)) }, + { json: "nauseation", js: "nauseation", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "preliberal", js: "preliberal", typ: u(undefined, i(0)) }, + { json: "prettifier", js: "prettifier", typ: u(undefined, i(0)) }, + { json: "rangework", js: "rangework", typ: u(undefined, i(0)) }, + { json: "redient", js: "redient", typ: u(undefined, i(0)) }, + { json: "subfusiform", js: "subfusiform", typ: u(undefined, i(0)) }, + { json: "suicidical", js: "suicidical", typ: u(undefined, i(0)) }, + { json: "swow", js: "swow", typ: u(undefined, i(0)) }, + { json: "wastrel", js: "wastrel", typ: u(undefined, i(0)) }, + { json: "wingle", js: "wingle", typ: u(undefined, i(0)) }, + ], false), + "GryphosaurusClass": o([ + { json: "Burushaski", js: "Burushaski", typ: null }, + { json: "Tahami", js: "Tahami", typ: null }, + { json: "amissibility", js: "amissibility", typ: null }, + { json: "citronin", js: "citronin", typ: null }, + { json: "coplaintiff", js: "coplaintiff", typ: null }, + { json: "disquisitionary", js: "disquisitionary", typ: null }, + { json: "enoplan", js: "enoplan", typ: null }, + { json: "faintness", js: "faintness", typ: null }, + { json: "hebetomy", js: "hebetomy", typ: null }, + { json: "islandry", js: "islandry", typ: null }, + { json: "lameduck", js: "lameduck", typ: null }, + { json: "overbattle", js: "overbattle", typ: null }, + { json: "overinterested", js: "overinterested", typ: null }, + { json: "phrenologic", js: "phrenologic", typ: null }, + { json: "rainband", js: "rainband", typ: null }, + { json: "shiningly", js: "shiningly", typ: null }, + { json: "stamineous", js: "stamineous", typ: null }, + { json: "subscapularis", js: "subscapularis", typ: null }, + { json: "undaubed", js: "undaubed", typ: null }, + { json: "underntime", js: "underntime", typ: null }, + ], false), + "LaviniaClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Tacana", js: "Tacana", typ: u(undefined, i(0)) }, + { json: "agitable", js: "agitable", typ: u(undefined, i(0)) }, + { json: "asininity", js: "asininity", typ: u(undefined, i(0)) }, + { json: "benefiter", js: "benefiter", typ: u(undefined, i(0)) }, + { json: "bronzelike", js: "bronzelike", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "cholesteatomatous", js: "cholesteatomatous", typ: u(undefined, i(0)) }, + { json: "deprivement", js: "deprivement", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "flippantness", js: "flippantness", typ: u(undefined, i(0)) }, + { json: "fogproof", js: "fogproof", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "merrymeeting", js: "merrymeeting", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "overcareful", js: "overcareful", typ: u(undefined, i(0)) }, + { json: "panaris", js: "panaris", typ: u(undefined, i(0)) }, + { json: "preacceptance", js: "preacceptance", typ: u(undefined, i(0)) }, + { json: "quinoxaline", js: "quinoxaline", typ: u(undefined, i(0)) }, + { json: "sig", js: "sig", typ: u(undefined, i(0)) }, + { json: "superconfusion", js: "superconfusion", typ: u(undefined, i(0)) }, + { json: "tillotter", js: "tillotter", typ: u(undefined, i(0)) }, + { json: "tranquillize", js: "tranquillize", typ: u(undefined, i(0)) }, + { json: "unquestionable", js: "unquestionable", typ: u(undefined, i(0)) }, + { json: "uproute", js: "uproute", typ: u(undefined, i(0)) }, + ], false), + "OskarClass": o([ + { json: "Acrobates", js: "Acrobates", typ: null }, + { json: "Cayuga", js: "Cayuga", typ: null }, + { json: "Netherlandish", js: "Netherlandish", typ: null }, + { json: "beanshooter", js: "beanshooter", typ: null }, + { json: "bearhound", js: "bearhound", typ: null }, + { json: "guarneri", js: "guarneri", typ: null }, + { json: "hypochondriacism", js: "hypochondriacism", typ: null }, + { json: "indication", js: "indication", typ: null }, + { json: "jaculative", js: "jaculative", typ: null }, + { json: "nagana", js: "nagana", typ: null }, + { json: "noctivagous", js: "noctivagous", typ: null }, + { json: "nonphysiological", js: "nonphysiological", typ: null }, + { json: "praxis", js: "praxis", typ: null }, + { json: "provision", js: "provision", typ: null }, + { json: "subterhuman", js: "subterhuman", typ: null }, + { json: "sunlit", js: "sunlit", typ: null }, + { json: "syncraniate", js: "syncraniate", typ: null }, + { json: "teachment", js: "teachment", typ: null }, + { json: "unmutinous", js: "unmutinous", typ: null }, + { json: "unstoppable", js: "unstoppable", typ: null }, + ], false), + "Rebecca": o([ + { json: "Chirotherium", js: "Chirotherium", typ: i(0) }, + { json: "catharticalness", js: "catharticalness", typ: 3.14 }, + { json: "disdiapason", js: "disdiapason", typ: "" }, + { json: "homocerc", js: "homocerc", typ: true }, + { json: "nonbookish", js: "nonbookish", typ: null }, + ], false), + "AlleviateClass": o([ + { json: "Hulsean", js: "Hulsean", typ: null }, + { json: "apriori", js: "apriori", typ: null }, + { json: "beggarer", js: "beggarer", typ: null }, + { json: "brokenheartedly", js: "brokenheartedly", typ: null }, + { json: "debilitation", js: "debilitation", typ: null }, + { json: "frike", js: "frike", typ: null }, + { json: "gastrolith", js: "gastrolith", typ: null }, + { json: "orthocentric", js: "orthocentric", typ: null }, + { json: "petaly", js: "petaly", typ: null }, + { json: "probudgeting", js: "probudgeting", typ: null }, + { json: "reacquire", js: "reacquire", typ: null }, + { json: "scow", js: "scow", typ: null }, + { json: "shutoff", js: "shutoff", typ: null }, + { json: "subcontiguous", js: "subcontiguous", typ: null }, + { json: "suffumigate", js: "suffumigate", typ: null }, + { json: "transformable", js: "transformable", typ: null }, + { json: "uncoroneted", js: "uncoroneted", typ: null }, + { json: "unparking", js: "unparking", typ: null }, + { json: "unvarnishedness", js: "unvarnishedness", typ: null }, + { json: "wherewithal", js: "wherewithal", typ: null }, + ], false), + "Amphithyron": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Juniperus", js: "Juniperus", typ: u(undefined, i(0)) }, + { json: "Nazirite", js: "Nazirite", typ: u(undefined, i(0)) }, + { json: "Those", js: "Those", typ: u(undefined, i(0)) }, + { json: "akroasis", js: "akroasis", typ: u(undefined, i(0)) }, + { json: "antiphonical", js: "antiphonical", typ: u(undefined, i(0)) }, + { json: "basebred", js: "basebred", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "conductometric", js: "conductometric", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "ensilation", js: "ensilation", typ: u(undefined, i(0)) }, + { json: "eyebolt", js: "eyebolt", typ: u(undefined, i(0)) }, + { json: "fistulated", js: "fistulated", typ: u(undefined, i(0)) }, + { json: "heteropod", js: "heteropod", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "labyrinthically", js: "labyrinthically", typ: u(undefined, i(0)) }, + { json: "martyrization", js: "martyrization", typ: u(undefined, i(0)) }, + { json: "mispolicy", js: "mispolicy", typ: u(undefined, i(0)) }, + { json: "multipara", js: "multipara", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "possessorial", js: "possessorial", typ: u(undefined, i(0)) }, + { json: "shamed", js: "shamed", typ: u(undefined, i(0)) }, + { json: "shelfworn", js: "shelfworn", typ: u(undefined, i(0)) }, + { json: "stagnum", js: "stagnum", typ: u(undefined, i(0)) }, + { json: "undecimal", js: "undecimal", typ: u(undefined, i(0)) }, + ], false), + "AnkeeClass": o([ + { json: "Anomoean", js: "Anomoean", typ: null }, + { json: "Naja", js: "Naja", typ: null }, + { json: "barleyhood", js: "barleyhood", typ: null }, + { json: "befriender", js: "befriender", typ: null }, + { json: "brutishness", js: "brutishness", typ: null }, + { json: "cephalalgy", js: "cephalalgy", typ: null }, + { json: "cirurgian", js: "cirurgian", typ: null }, + { json: "conventionally", js: "conventionally", typ: null }, + { json: "jackshay", js: "jackshay", typ: null }, + { json: "milammeter", js: "milammeter", typ: null }, + { json: "ombrological", js: "ombrological", typ: null }, + { json: "phonasthenia", js: "phonasthenia", typ: null }, + { json: "retrievableness", js: "retrievableness", typ: null }, + { json: "snakily", js: "snakily", typ: null }, + { json: "swot", js: "swot", typ: null }, + { json: "tartlet", js: "tartlet", typ: null }, + { json: "thiofuran", js: "thiofuran", typ: null }, + { json: "tracheophone", js: "tracheophone", typ: null }, + { json: "tuglike", js: "tuglike", typ: null }, + { json: "unscratchingly", js: "unscratchingly", typ: null }, + ], false), +}; diff --git a/base/typescript/test/inputs/json/priority/combinations2.json/prefer-unions-false--a5053c0a486d/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations2.json/prefer-unions-false--a5053c0a486d/TopLevel.ts index fd1800c..1672405 100644 --- a/base/typescript/test/inputs/json/priority/combinations2.json/prefer-unions-false--a5053c0a486d/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations2.json/prefer-unions-false--a5053c0a486d/TopLevel.ts @@ -479,7 +479,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations2.json/prefer-unknown-false--f1ab9e45d823/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations2.json/prefer-unknown-false--f1ab9e45d823/TopLevel.ts index fd1800c..1672405 100644 --- a/base/typescript/test/inputs/json/priority/combinations2.json/prefer-unknown-false--f1ab9e45d823/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations2.json/prefer-unknown-false--f1ab9e45d823/TopLevel.ts @@ -479,7 +479,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations2.json/readonly-true--24da4fc107df/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations2.json/readonly-true--24da4fc107df/TopLevel.ts index a5a423e..85e19ba 100644 --- a/base/typescript/test/inputs/json/priority/combinations2.json/readonly-true--24da4fc107df/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations2.json/readonly-true--24da4fc107df/TopLevel.ts @@ -479,7 +479,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations2.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations2.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.ts index f1e2650..9bc85f6 100644 --- a/base/typescript/test/inputs/json/priority/combinations2.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations2.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.ts @@ -479,7 +479,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations3.json/acronym-style-pascal--d9e0c1bd777a/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations3.json/acronym-style-pascal--d9e0c1bd777a/TopLevel.ts index e726dc5..91fda79 100644 --- a/base/typescript/test/inputs/json/priority/combinations3.json/acronym-style-pascal--d9e0c1bd777a/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations3.json/acronym-style-pascal--d9e0c1bd777a/TopLevel.ts @@ -583,7 +583,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations3.json/converters-all-objects--3a443babd1cb/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations3.json/converters-all-objects--3a443babd1cb/TopLevel.ts index c322233..ef8844b 100644 --- a/base/typescript/test/inputs/json/priority/combinations3.json/converters-all-objects--3a443babd1cb/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations3.json/converters-all-objects--3a443babd1cb/TopLevel.ts @@ -695,7 +695,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations3.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations3.json/default/TopLevel.ts index e726dc5..91fda79 100644 --- a/base/typescript/test/inputs/json/priority/combinations3.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations3.json/default/TopLevel.ts @@ -583,7 +583,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations3.json/nice-property-names-true--f4d7920ee2ce/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations3.json/nice-property-names-true--f4d7920ee2ce/TopLevel.ts index 91ddca4..942b1a8 100644 --- a/base/typescript/test/inputs/json/priority/combinations3.json/nice-property-names-true--f4d7920ee2ce/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations3.json/nice-property-names-true--f4d7920ee2ce/TopLevel.ts @@ -583,7 +583,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/head/typescript/test/inputs/json/priority/combinations3.json/prefer-const-values-true--6b26e4d1265c/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations3.json/prefer-const-values-true--6b26e4d1265c/TopLevel.ts new file mode 100644 index 0000000..91fda79 --- /dev/null +++ b/head/typescript/test/inputs/json/priority/combinations3.json/prefer-const-values-true--6b26e4d1265c/TopLevel.ts @@ -0,0 +1,1016 @@ +// To parse this data: +// +// import { Convert, TopLevel } from "./TopLevel"; +// +// const topLevel = Convert.toTopLevel(json); +// +// These functions will throw an error if the JSON doesn't +// match the expected interface, even if the JSON is valid. + +export interface TopLevel { + juror: JurorElement[]; + kongoni: Kongoni[]; + ladronism: LadronismElement[]; + landlubberly: LandlubberlyElement[]; + listener: Listener[]; + lupus: LupusElement[]; + maslin: Maslin[]; + monazite: MonaziteElement[]; + monoliteral: Monoliteral[]; + monotheistically: MonotheisticallyElement[]; + montage: Montage[]; + moralness: Moralness[]; + mowra: (MonaziteClass | null)[]; + mulishly: Mulishly[]; + myoscope: Myoscope[]; + nach: ((number | null)[] | null)[]; + neuromastic: Neuromastic[]; + noncontributing: Noncontributing[]; + nonnervous: Nonnervous[]; + nonvaluation: Nonvaluation[]; + occupationalist: OccupationalistElement[]; + outrival: OutrivalElement[]; + paleographically: Paleographically[]; + pamphletwise: Pamphletwise[]; + pediatrics: Pediatric[]; + perceptive: boolean[]; + piaculum: PiaculumElement[]; + piccadilly: Piccadilly[]; + piffler: Piffler[]; + pithful: Pithful[]; + placuntitis: Placuntiti[]; + plectopterous: Plectopterous[]; + pneumocele: (Pneumocele | null)[]; + poliorcetic: Poliorcetic[]; + poormaster: Poormaster[]; + potwhisky: PotwhiskyElement[]; + practicalizer: Practicalizer[]; + prefreshman: PrefreshmanElement[]; + prehensility: Prehensility[]; + prevoidance: Prevoidance[]; + probant: { [key: string]: number | null }[]; + protext: Protext[]; +} + +export type JurorElement = boolean | JurorClass; + +export interface JurorClass { + Olea: null; + adipsy: null; + auxiliator: null; + benda: null; + benjamin: null; + brandling: null; + epicurishly: null; + eremochaetous: null; + marten: null; + monocline: null; + palgat: null; + pennyworth: null; + pioury: null; + pragmatistic: null; + stylelessness: null; + systematical: null; + thready: null; + uncontemporary: null; + uncouched: null; + uninhabitedness: null; +} + +export type Kongoni = number[] | { [key: string]: number }; + +export type LadronismElement = LadronismClass | number | string; + +export interface LadronismClass { + Prodenia: null; + acclaimer: null; + achree: null; + base: null; + conundrumize: null; + degerminator: null; + describable: null; + exasperatedly: null; + heroine: null; + indazin: null; + luteous: null; + papular: null; + pritch: null; + seege: null; + shopgirl: null; + tragedietta: null; + unsparse: null; + uplook: null; + vermiformis: null; + whafabout: null; +} + +export type LandlubberlyElement = boolean | LandlubberlyClass | number; + +export interface LandlubberlyClass { + Amyraldism: null; + acropoleis: null; + aminate: null; + bipenniform: null; + bugre: null; + calycule: null; + caoutchouc: null; + disprover: null; + fitroot: null; + fulgently: null; + kickup: null; + laevoversion: null; + moter: null; + objectivity: null; + posterity: null; + postnuptial: null; + precedentary: null; + saddling: null; + subcurrent: null; + unrecriminative: null; +} + +export type Listener = null[] | number; + +export type LupusElement = LupusClass | number; + +export interface LupusClass { + Chirotherium?: number; + Chlorioninae?: number; + Corvinae?: number; + Crassina?: number; + Thysanocarpus?: number; + catharticalness?: number; + disdiapason?: string; + exiguity?: number; + farcist?: number; + holographical?: number; + homocerc?: boolean; + ichthyophagan?: number; + implacable?: number; + nonbookish?: null; + outshiner?: number; + overweather?: number; + protonegroid?: number; + shallowish?: number; + snoke?: number; + snout?: number; + surveillance?: number; + threshingtime?: number; + unsignificantly?: number; + unsnap?: number; + vendible?: number; +} + +export interface Maslin { + Alicant?: number; + Bakuninist?: null; + Chirotherium?: number; + Dimitry?: number; + antiatonement?: null; + anticorrosive?: number; + aphidozer?: null; + be?: number; + catharticalness?: number; + chub?: number; + cuprosilicon?: number; + curtailedly?: number; + dellenite?: number; + disdiapason?: string; + edifying?: null; + ethmoiditis?: number; + gastralgy?: null; + goatherd?: number; + hammerdress?: number; + hangfire?: null; + homocerc?: boolean; + lacunosity?: number; + longiloquence?: null; + mameliere?: number; + motherless?: null; + nonbookish?: null; + noncorrodible?: null; + nonsensicality?: null; + oafishly?: number; + pfund?: null; + preadvisory?: null; + retroflexed?: null; + saccharulmic?: number; + scowlful?: number; + secluded?: null; + slackage?: null; + sphaeridial?: number; + spondulics?: null; + subsecive?: number; + swellmobsman?: null; + trachyglossate?: number; + trialogue?: null; + unassuaged?: number; + ungross?: null; + unjudiciously?: null; +} + +export type MonaziteElement = MonaziteClass | number; + +export interface MonaziteClass { + Chirotherium: number; + catharticalness: number; + disdiapason: string; + homocerc: boolean; + nonbookish: null; +} + +export type Monoliteral = null[] | boolean; + +export type MonotheisticallyElement = null[] | MonotheisticallyClass; + +export interface MonotheisticallyClass { + Chirotherium?: number; + blaspheme?: null; + catharticalness?: number; + celiosalpingectomy?: null; + consummativeness?: null; + disdiapason?: string; + egestive?: null; + enchylema?: null; + gasconade?: null; + holidayer?: null; + homocerc?: boolean; + intuitionalism?: null; + lophiostomate?: null; + nonbookish?: null; + nonvolition?: null; + palatableness?: null; + pimpery?: null; + previolation?: null; + reconveyance?: null; + registership?: null; + rhyacolite?: null; + smithereens?: null; + superedification?: null; + trust?: null; + whitestone?: null; +} + +export type Montage = null[] | number | string; + +export type Moralness = null[] | number | null; + +export type Mulishly = number[] | number | null; + +export type Myoscope = null[] | boolean | number; + +export type Neuromastic = null[] | number; + +export interface Noncontributing { + estevin: string; + jolterhead: number; + sauternes: number; + sparsely: boolean; + unrequested: null; +} + +export type Nonnervous = boolean | number; + +export type Nonvaluation = null[] | boolean | number; + +export type OccupationalistElement = null[] | OccupationalistClass | null; + +export interface OccupationalistClass { + Chimakum: null; + Fin: null; + beholdable: null; + brotuliform: null; + doodler: null; + emulsin: null; + flourishing: null; + flueless: null; + furtively: null; + gritter: null; + interwish: null; + monoxylic: null; + myristic: null; + nightwear: null; + peruser: null; + theoastrological: null; + thumby: null; + tingitid: null; + trailless: null; + unpocketed: null; +} + +export type OutrivalElement = OutrivalClass | number | null; + +export interface OutrivalClass { + Castoroides: null; + Czechoslovak: null; + Lingulidae: null; + adroitly: null; + bridehood: null; + diagenesis: null; + dihexahedron: null; + dopester: null; + eumerism: null; + flyness: null; + fouler: null; + laudanosine: null; + minutary: null; + mitra: null; + opisthorchiasis: null; + pensively: null; + pubigerous: null; + rebellious: null; + recodify: null; + unpaced: null; +} + +export type Paleographically = number | { [key: string]: number | null }; + +export type Pamphletwise = number | { [key: string]: number } | string; + +export type Pediatric = boolean | number | null; + +export type PiaculumElement = PiaculumClass | number; + +export interface PiaculumClass { + Chirotherium?: number; + Zipper?: number; + alada?: number; + amphistomous?: number; + boysenberry?: number; + catharticalness?: number; + decardinalize?: number; + discouragement?: number; + disdiapason?: string; + doitrified?: number; + hexaspermous?: number; + homocerc?: boolean; + insinking?: number; + loathfulness?: number; + miasmatical?: number; + neurofibril?: number; + nonbookish?: null; + phonendoscope?: number; + pilferment?: number; + predismissory?: number; + preinscription?: number; + quotative?: number; + sienna?: number; + thorax?: number; + yachting?: number; +} + +export type Piccadilly = number | null | string; + +export type Piffler = null[] | MonaziteClass; + +export type Pithful = boolean | number | null; + +export type Placuntiti = number | { [key: string]: number }; + +export type Plectopterous = number | { [key: string]: number }; + +export interface Pneumocele { + Carbonarism?: null; + Chirotherium?: number; + Koniga?: null; + Micky?: null; + catharticalness?: number; + cineolic?: null; + cobbly?: null; + conchyliferous?: null; + congregation?: null; + disdiapason?: string; + enterotomy?: null; + entophytal?: null; + fewtrils?: null; + herem?: null; + homocerc?: boolean; + meticulosity?: null; + mismarriage?: null; + neurotrophic?: null; + nonbookish?: null; + persuasively?: null; + replaceable?: null; + silex?: null; + taillight?: null; + unjealous?: null; + visitorial?: null; +} + +export type Poliorcetic = boolean | MonaziteClass; + +export type Poormaster = number[] | { [key: string]: number } | null; + +export type PotwhiskyElement = PotwhiskyClass | number | null; + +export interface PotwhiskyClass { + Euchorda: null; + Yoruba: null; + arciform: null; + cresolin: null; + disheartener: null; + disproportionable: null; + ferryway: null; + filamentiferous: null; + flemish: null; + forgainst: null; + grainering: null; + irrevoluble: null; + kindredship: null; + pinguitudinous: null; + simpletonic: null; + singsong: null; + submergement: null; + supraoesophagal: null; + thrashel: null; + tyremesis: null; +} + +export type Practicalizer = null[] | MonaziteClass | string; + +export type PrefreshmanElement = null[] | PrefreshmanClass | string; + +export interface PrefreshmanClass { + Dolphus: null; + Ficus: null; + Gemaric: null; + Phaet: null; + azorubine: null; + choroiditis: null; + coagulatory: null; + cyclorama: null; + duckhearted: null; + jugation: null; + myoliposis: null; + nonnomination: null; + palay: null; + pentactinal: null; + piquant: null; + registration: null; + remancipation: null; + scutatiform: null; + theodolite: null; + underward: null; +} + +export type Prehensility = null[] | boolean | MonaziteClass; + +export type Prevoidance = number[] | MonaziteClass | number; + +export type Protext = number[] | boolean | MonaziteClass; + +// Converts JSON strings to/from your types +// and asserts the results of JSON.parse at runtime +export class Convert { + public static toTopLevel(json: string): TopLevel { + return cast(JSON.parse(json), r("TopLevel")); + } + + public static topLevelToJson(value: TopLevel): string { + return JSON.stringify(uncast(value, r("TopLevel")), null, 2); + } +} + +function invalidValue(typ: any, val: any, key: any, parent: any = ''): never { + const prettyTyp = prettyTypeName(typ); + const parentText = parent ? ` on ${parent}` : ''; + const keyText = key ? ` for key "${key}"` : ''; + throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`); +} + +function prettyTypeName(typ: any): string { + if (Array.isArray(typ)) { + if (typ.length === 2 && typ[0] === undefined) { + return `an optional ${prettyTypeName(typ[1])}`; + } else { + return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`; + } + } else if (typeof typ === "object" && typ.literal !== undefined) { + return typ.literal; + } else { + return typeof typ; + } +} + +function jsonToJSProps(typ: any): any { + if (typ.jsonToJS === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ }); + typ.jsonToJS = map; + } + return typ.jsonToJS; +} + +function jsToJSONProps(typ: any): any { + if (typ.jsToJSON === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ }); + typ.jsToJSON = map; + } + return typ.jsToJSON; +} + +function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any { + function transformPrimitive(typ: string, val: any): any { + if (typeof typ === typeof val) return val; + return invalidValue(typ, val, key, parent); + } + + function transformUnion(typs: any[], val: any): any { + // val must validate against one typ in typs + const l = typs.length; + for (let i = 0; i < l; i++) { + const typ = typs[i]; + try { + return transform(val, typ, getProps); + } catch (_) {} + } + return invalidValue(typs, val, key, parent); + } + + function transformEnum(cases: string[], val: any): any { + if (cases.indexOf(val) !== -1) return val; + return invalidValue(cases.map(a => { return l(a); }), val, key, parent); + } + + function transformArray(typ: any, val: any): any { + // val must be an array with no invalid elements + if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent); + + return val.map(el => transform(el, typ, getProps)); + } + + function transformDate(val: any): any { + if (val === null) { + return null; + } + const d = new Date(val); + if (isNaN(d.valueOf())) { + return invalidValue(l("Date"), val, key, parent); + } + return d; + } + + function transformObject(props: { [k: string]: any }, additional: any, val: any): any { + if (val === null || typeof val !== "object" || Array.isArray(val)) { + return invalidValue(l(ref || "object"), val, key, parent); + } + const result: any = {}; + Object.getOwnPropertyNames(props).forEach(key => { + const prop = props[key]; + const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined; + result[prop.key] = transform(v, prop.typ, getProps, key, ref); + }); + Object.getOwnPropertyNames(val).forEach(key => { + if (!Object.prototype.hasOwnProperty.call(props, key)) { + result[key] = transform(val[key], additional, getProps, key, ref); + } + }); + return result; + } + + if (typ === "any") return val; + if (typ === null) { + if (val === null) return val; + return invalidValue(typ, val, key, parent); + } + if (typ === false) return invalidValue(typ, val, key, parent); + let ref: any = undefined; + while (typeof typ === "object" && typ.ref !== undefined) { + ref = typ.ref; + typ = typeMap[typ.ref]; + } + if (Array.isArray(typ)) return transformEnum(typ, val); + if (typeof typ === "object") { + return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) + : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) + : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val) + : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val) + : invalidValue(typ, val, key, parent); + } + // Numbers can be parsed by Date but shouldn't be. + if (typ === Date && typeof val !== "number") return transformDate(val); + return transformPrimitive(typ, val); +} + +function cast(val: any, typ: any): T { + return transform(val, typ, jsonToJSProps); +} + +function uncast(val: T, typ: any): any { + return transform(val, typ, jsToJSONProps); +} + +function l(typ: any) { + return { literal: typ }; +} + +function a(typ: any) { + return { arrayItems: typ }; +} + +function i(typ: any) { + return { integer: typ }; +} + +function p(pattern: any) { + return { pattern }; +} + +function s(typ: any, min: any, max: any) { + return { string: typ, min, max }; +} + +function n(typ: any, min: any, max: any) { + return { number: typ, min, max }; +} + +function u(...typs: any[]) { + return { unionMembers: typs }; +} + +function o(props: any[], additional: any) { + return { props, additional }; +} + +function m(additional: any) { + const props: any[] = []; + return { props, additional }; +} + +function r(name: string) { + return { ref: name }; +} + +const typeMap: any = { + "TopLevel": o([ + { json: "juror", js: "juror", typ: a(u(true, r("JurorClass"))) }, + { json: "kongoni", js: "kongoni", typ: a(u(a(i(0)), m(i(0)))) }, + { json: "ladronism", js: "ladronism", typ: a(u(r("LadronismClass"), 3.14, "")) }, + { json: "landlubberly", js: "landlubberly", typ: a(u(true, r("LandlubberlyClass"), i(0))) }, + { json: "listener", js: "listener", typ: a(u(a(null), i(0))) }, + { json: "lupus", js: "lupus", typ: a(u(r("LupusClass"), i(0))) }, + { json: "maslin", js: "maslin", typ: a(r("Maslin")) }, + { json: "monazite", js: "monazite", typ: a(u(r("MonaziteClass"), 3.14)) }, + { json: "monoliteral", js: "monoliteral", typ: a(u(a(null), true)) }, + { json: "monotheistically", js: "monotheistically", typ: a(u(a(null), r("MonotheisticallyClass"))) }, + { json: "montage", js: "montage", typ: a(u(a(null), 3.14, "")) }, + { json: "moralness", js: "moralness", typ: a(u(a(null), 3.14, null)) }, + { json: "mowra", js: "mowra", typ: a(u(r("MonaziteClass"), null)) }, + { json: "mulishly", js: "mulishly", typ: a(u(a(i(0)), 3.14, null)) }, + { json: "myoscope", js: "myoscope", typ: a(u(a(null), true, i(0))) }, + { json: "nach", js: "nach", typ: a(u(a(u(i(0), null)), null)) }, + { json: "neuromastic", js: "neuromastic", typ: a(u(a(null), 3.14)) }, + { json: "noncontributing", js: "noncontributing", typ: a(r("Noncontributing")) }, + { json: "nonnervous", js: "nonnervous", typ: a(u(true, i(0))) }, + { json: "nonvaluation", js: "nonvaluation", typ: a(u(a(null), true, 3.14)) }, + { json: "occupationalist", js: "occupationalist", typ: a(u(a(null), r("OccupationalistClass"), null)) }, + { json: "outrival", js: "outrival", typ: a(u(r("OutrivalClass"), 3.14, null)) }, + { json: "paleographically", js: "paleographically", typ: a(u(3.14, m(u(i(0), null)))) }, + { json: "pamphletwise", js: "pamphletwise", typ: a(u(i(0), m(i(0)), "")) }, + { json: "pediatrics", js: "pediatrics", typ: a(u(true, 3.14, null)) }, + { json: "perceptive", js: "perceptive", typ: a(true) }, + { json: "piaculum", js: "piaculum", typ: a(u(r("PiaculumClass"), 3.14)) }, + { json: "piccadilly", js: "piccadilly", typ: a(u(3.14, null, "")) }, + { json: "piffler", js: "piffler", typ: a(u(a(null), r("MonaziteClass"))) }, + { json: "pithful", js: "pithful", typ: a(u(true, i(0), null)) }, + { json: "placuntitis", js: "placuntitis", typ: a(u(i(0), m(i(0)))) }, + { json: "plectopterous", js: "plectopterous", typ: a(u(3.14, m(i(0)))) }, + { json: "pneumocele", js: "pneumocele", typ: a(u(r("Pneumocele"), null)) }, + { json: "poliorcetic", js: "poliorcetic", typ: a(u(true, r("MonaziteClass"))) }, + { json: "poormaster", js: "poormaster", typ: a(u(a(i(0)), m(i(0)), null)) }, + { json: "potwhisky", js: "potwhisky", typ: a(u(r("PotwhiskyClass"), i(0), null)) }, + { json: "practicalizer", js: "practicalizer", typ: a(u(a(null), r("MonaziteClass"), "")) }, + { json: "prefreshman", js: "prefreshman", typ: a(u(a(null), r("PrefreshmanClass"), "")) }, + { json: "prehensility", js: "prehensility", typ: a(u(a(null), true, r("MonaziteClass"))) }, + { json: "prevoidance", js: "prevoidance", typ: a(u(a(i(0)), r("MonaziteClass"), i(0))) }, + { json: "probant", js: "probant", typ: a(m(u(i(0), null))) }, + { json: "protext", js: "protext", typ: a(u(a(i(0)), true, r("MonaziteClass"))) }, + ], false), + "JurorClass": o([ + { json: "Olea", js: "Olea", typ: null }, + { json: "adipsy", js: "adipsy", typ: null }, + { json: "auxiliator", js: "auxiliator", typ: null }, + { json: "benda", js: "benda", typ: null }, + { json: "benjamin", js: "benjamin", typ: null }, + { json: "brandling", js: "brandling", typ: null }, + { json: "epicurishly", js: "epicurishly", typ: null }, + { json: "eremochaetous", js: "eremochaetous", typ: null }, + { json: "marten", js: "marten", typ: null }, + { json: "monocline", js: "monocline", typ: null }, + { json: "palgat", js: "palgat", typ: null }, + { json: "pennyworth", js: "pennyworth", typ: null }, + { json: "pioury", js: "pioury", typ: null }, + { json: "pragmatistic", js: "pragmatistic", typ: null }, + { json: "stylelessness", js: "stylelessness", typ: null }, + { json: "systematical", js: "systematical", typ: null }, + { json: "thready", js: "thready", typ: null }, + { json: "uncontemporary", js: "uncontemporary", typ: null }, + { json: "uncouched", js: "uncouched", typ: null }, + { json: "uninhabitedness", js: "uninhabitedness", typ: null }, + ], false), + "LadronismClass": o([ + { json: "Prodenia", js: "Prodenia", typ: null }, + { json: "acclaimer", js: "acclaimer", typ: null }, + { json: "achree", js: "achree", typ: null }, + { json: "base", js: "base", typ: null }, + { json: "conundrumize", js: "conundrumize", typ: null }, + { json: "degerminator", js: "degerminator", typ: null }, + { json: "describable", js: "describable", typ: null }, + { json: "exasperatedly", js: "exasperatedly", typ: null }, + { json: "heroine", js: "heroine", typ: null }, + { json: "indazin", js: "indazin", typ: null }, + { json: "luteous", js: "luteous", typ: null }, + { json: "papular", js: "papular", typ: null }, + { json: "pritch", js: "pritch", typ: null }, + { json: "seege", js: "seege", typ: null }, + { json: "shopgirl", js: "shopgirl", typ: null }, + { json: "tragedietta", js: "tragedietta", typ: null }, + { json: "unsparse", js: "unsparse", typ: null }, + { json: "uplook", js: "uplook", typ: null }, + { json: "vermiformis", js: "vermiformis", typ: null }, + { json: "whafabout", js: "whafabout", typ: null }, + ], false), + "LandlubberlyClass": o([ + { json: "Amyraldism", js: "Amyraldism", typ: null }, + { json: "acropoleis", js: "acropoleis", typ: null }, + { json: "aminate", js: "aminate", typ: null }, + { json: "bipenniform", js: "bipenniform", typ: null }, + { json: "bugre", js: "bugre", typ: null }, + { json: "calycule", js: "calycule", typ: null }, + { json: "caoutchouc", js: "caoutchouc", typ: null }, + { json: "disprover", js: "disprover", typ: null }, + { json: "fitroot", js: "fitroot", typ: null }, + { json: "fulgently", js: "fulgently", typ: null }, + { json: "kickup", js: "kickup", typ: null }, + { json: "laevoversion", js: "laevoversion", typ: null }, + { json: "moter", js: "moter", typ: null }, + { json: "objectivity", js: "objectivity", typ: null }, + { json: "posterity", js: "posterity", typ: null }, + { json: "postnuptial", js: "postnuptial", typ: null }, + { json: "precedentary", js: "precedentary", typ: null }, + { json: "saddling", js: "saddling", typ: null }, + { json: "subcurrent", js: "subcurrent", typ: null }, + { json: "unrecriminative", js: "unrecriminative", typ: null }, + ], false), + "LupusClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Chlorioninae", js: "Chlorioninae", typ: u(undefined, i(0)) }, + { json: "Corvinae", js: "Corvinae", typ: u(undefined, i(0)) }, + { json: "Crassina", js: "Crassina", typ: u(undefined, i(0)) }, + { json: "Thysanocarpus", js: "Thysanocarpus", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "exiguity", js: "exiguity", typ: u(undefined, i(0)) }, + { json: "farcist", js: "farcist", typ: u(undefined, i(0)) }, + { json: "holographical", js: "holographical", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "ichthyophagan", js: "ichthyophagan", typ: u(undefined, i(0)) }, + { json: "implacable", js: "implacable", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "outshiner", js: "outshiner", typ: u(undefined, i(0)) }, + { json: "overweather", js: "overweather", typ: u(undefined, i(0)) }, + { json: "protonegroid", js: "protonegroid", typ: u(undefined, i(0)) }, + { json: "shallowish", js: "shallowish", typ: u(undefined, i(0)) }, + { json: "snoke", js: "snoke", typ: u(undefined, i(0)) }, + { json: "snout", js: "snout", typ: u(undefined, i(0)) }, + { json: "surveillance", js: "surveillance", typ: u(undefined, i(0)) }, + { json: "threshingtime", js: "threshingtime", typ: u(undefined, i(0)) }, + { json: "unsignificantly", js: "unsignificantly", typ: u(undefined, i(0)) }, + { json: "unsnap", js: "unsnap", typ: u(undefined, i(0)) }, + { json: "vendible", js: "vendible", typ: u(undefined, i(0)) }, + ], false), + "Maslin": o([ + { json: "Alicant", js: "Alicant", typ: u(undefined, i(0)) }, + { json: "Bakuninist", js: "Bakuninist", typ: u(undefined, null) }, + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Dimitry", js: "Dimitry", typ: u(undefined, i(0)) }, + { json: "antiatonement", js: "antiatonement", typ: u(undefined, null) }, + { json: "anticorrosive", js: "anticorrosive", typ: u(undefined, i(0)) }, + { json: "aphidozer", js: "aphidozer", typ: u(undefined, null) }, + { json: "be", js: "be", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "chub", js: "chub", typ: u(undefined, i(0)) }, + { json: "cuprosilicon", js: "cuprosilicon", typ: u(undefined, i(0)) }, + { json: "curtailedly", js: "curtailedly", typ: u(undefined, i(0)) }, + { json: "dellenite", js: "dellenite", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "edifying", js: "edifying", typ: u(undefined, null) }, + { json: "ethmoiditis", js: "ethmoiditis", typ: u(undefined, i(0)) }, + { json: "gastralgy", js: "gastralgy", typ: u(undefined, null) }, + { json: "goatherd", js: "goatherd", typ: u(undefined, i(0)) }, + { json: "hammerdress", js: "hammerdress", typ: u(undefined, i(0)) }, + { json: "hangfire", js: "hangfire", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "lacunosity", js: "lacunosity", typ: u(undefined, i(0)) }, + { json: "longiloquence", js: "longiloquence", typ: u(undefined, null) }, + { json: "mameliere", js: "mameliere", typ: u(undefined, i(0)) }, + { json: "motherless", js: "motherless", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "noncorrodible", js: "noncorrodible", typ: u(undefined, null) }, + { json: "nonsensicality", js: "nonsensicality", typ: u(undefined, null) }, + { json: "oafishly", js: "oafishly", typ: u(undefined, i(0)) }, + { json: "pfund", js: "pfund", typ: u(undefined, null) }, + { json: "preadvisory", js: "preadvisory", typ: u(undefined, null) }, + { json: "retroflexed", js: "retroflexed", typ: u(undefined, null) }, + { json: "saccharulmic", js: "saccharulmic", typ: u(undefined, i(0)) }, + { json: "scowlful", js: "scowlful", typ: u(undefined, i(0)) }, + { json: "secluded", js: "secluded", typ: u(undefined, null) }, + { json: "slackage", js: "slackage", typ: u(undefined, null) }, + { json: "sphaeridial", js: "sphaeridial", typ: u(undefined, i(0)) }, + { json: "spondulics", js: "spondulics", typ: u(undefined, null) }, + { json: "subsecive", js: "subsecive", typ: u(undefined, i(0)) }, + { json: "swellmobsman", js: "swellmobsman", typ: u(undefined, null) }, + { json: "trachyglossate", js: "trachyglossate", typ: u(undefined, i(0)) }, + { json: "trialogue", js: "trialogue", typ: u(undefined, null) }, + { json: "unassuaged", js: "unassuaged", typ: u(undefined, i(0)) }, + { json: "ungross", js: "ungross", typ: u(undefined, null) }, + { json: "unjudiciously", js: "unjudiciously", typ: u(undefined, null) }, + ], false), + "MonaziteClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: i(0) }, + { json: "catharticalness", js: "catharticalness", typ: 3.14 }, + { json: "disdiapason", js: "disdiapason", typ: "" }, + { json: "homocerc", js: "homocerc", typ: true }, + { json: "nonbookish", js: "nonbookish", typ: null }, + ], false), + "MonotheisticallyClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "blaspheme", js: "blaspheme", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "celiosalpingectomy", js: "celiosalpingectomy", typ: u(undefined, null) }, + { json: "consummativeness", js: "consummativeness", typ: u(undefined, null) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "egestive", js: "egestive", typ: u(undefined, null) }, + { json: "enchylema", js: "enchylema", typ: u(undefined, null) }, + { json: "gasconade", js: "gasconade", typ: u(undefined, null) }, + { json: "holidayer", js: "holidayer", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "intuitionalism", js: "intuitionalism", typ: u(undefined, null) }, + { json: "lophiostomate", js: "lophiostomate", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "nonvolition", js: "nonvolition", typ: u(undefined, null) }, + { json: "palatableness", js: "palatableness", typ: u(undefined, null) }, + { json: "pimpery", js: "pimpery", typ: u(undefined, null) }, + { json: "previolation", js: "previolation", typ: u(undefined, null) }, + { json: "reconveyance", js: "reconveyance", typ: u(undefined, null) }, + { json: "registership", js: "registership", typ: u(undefined, null) }, + { json: "rhyacolite", js: "rhyacolite", typ: u(undefined, null) }, + { json: "smithereens", js: "smithereens", typ: u(undefined, null) }, + { json: "superedification", js: "superedification", typ: u(undefined, null) }, + { json: "trust", js: "trust", typ: u(undefined, null) }, + { json: "whitestone", js: "whitestone", typ: u(undefined, null) }, + ], false), + "Noncontributing": o([ + { json: "estevin", js: "estevin", typ: "" }, + { json: "jolterhead", js: "jolterhead", typ: 3.14 }, + { json: "sauternes", js: "sauternes", typ: i(0) }, + { json: "sparsely", js: "sparsely", typ: true }, + { json: "unrequested", js: "unrequested", typ: null }, + ], false), + "OccupationalistClass": o([ + { json: "Chimakum", js: "Chimakum", typ: null }, + { json: "Fin", js: "Fin", typ: null }, + { json: "beholdable", js: "beholdable", typ: null }, + { json: "brotuliform", js: "brotuliform", typ: null }, + { json: "doodler", js: "doodler", typ: null }, + { json: "emulsin", js: "emulsin", typ: null }, + { json: "flourishing", js: "flourishing", typ: null }, + { json: "flueless", js: "flueless", typ: null }, + { json: "furtively", js: "furtively", typ: null }, + { json: "gritter", js: "gritter", typ: null }, + { json: "interwish", js: "interwish", typ: null }, + { json: "monoxylic", js: "monoxylic", typ: null }, + { json: "myristic", js: "myristic", typ: null }, + { json: "nightwear", js: "nightwear", typ: null }, + { json: "peruser", js: "peruser", typ: null }, + { json: "theoastrological", js: "theoastrological", typ: null }, + { json: "thumby", js: "thumby", typ: null }, + { json: "tingitid", js: "tingitid", typ: null }, + { json: "trailless", js: "trailless", typ: null }, + { json: "unpocketed", js: "unpocketed", typ: null }, + ], false), + "OutrivalClass": o([ + { json: "Castoroides", js: "Castoroides", typ: null }, + { json: "Czechoslovak", js: "Czechoslovak", typ: null }, + { json: "Lingulidae", js: "Lingulidae", typ: null }, + { json: "adroitly", js: "adroitly", typ: null }, + { json: "bridehood", js: "bridehood", typ: null }, + { json: "diagenesis", js: "diagenesis", typ: null }, + { json: "dihexahedron", js: "dihexahedron", typ: null }, + { json: "dopester", js: "dopester", typ: null }, + { json: "eumerism", js: "eumerism", typ: null }, + { json: "flyness", js: "flyness", typ: null }, + { json: "fouler", js: "fouler", typ: null }, + { json: "laudanosine", js: "laudanosine", typ: null }, + { json: "minutary", js: "minutary", typ: null }, + { json: "mitra", js: "mitra", typ: null }, + { json: "opisthorchiasis", js: "opisthorchiasis", typ: null }, + { json: "pensively", js: "pensively", typ: null }, + { json: "pubigerous", js: "pubigerous", typ: null }, + { json: "rebellious", js: "rebellious", typ: null }, + { json: "recodify", js: "recodify", typ: null }, + { json: "unpaced", js: "unpaced", typ: null }, + ], false), + "PiaculumClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Zipper", js: "Zipper", typ: u(undefined, i(0)) }, + { json: "alada", js: "alada", typ: u(undefined, i(0)) }, + { json: "amphistomous", js: "amphistomous", typ: u(undefined, i(0)) }, + { json: "boysenberry", js: "boysenberry", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "decardinalize", js: "decardinalize", typ: u(undefined, i(0)) }, + { json: "discouragement", js: "discouragement", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "doitrified", js: "doitrified", typ: u(undefined, i(0)) }, + { json: "hexaspermous", js: "hexaspermous", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "insinking", js: "insinking", typ: u(undefined, i(0)) }, + { json: "loathfulness", js: "loathfulness", typ: u(undefined, i(0)) }, + { json: "miasmatical", js: "miasmatical", typ: u(undefined, i(0)) }, + { json: "neurofibril", js: "neurofibril", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "phonendoscope", js: "phonendoscope", typ: u(undefined, i(0)) }, + { json: "pilferment", js: "pilferment", typ: u(undefined, i(0)) }, + { json: "predismissory", js: "predismissory", typ: u(undefined, i(0)) }, + { json: "preinscription", js: "preinscription", typ: u(undefined, i(0)) }, + { json: "quotative", js: "quotative", typ: u(undefined, i(0)) }, + { json: "sienna", js: "sienna", typ: u(undefined, i(0)) }, + { json: "thorax", js: "thorax", typ: u(undefined, i(0)) }, + { json: "yachting", js: "yachting", typ: u(undefined, i(0)) }, + ], false), + "Pneumocele": o([ + { json: "Carbonarism", js: "Carbonarism", typ: u(undefined, null) }, + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Koniga", js: "Koniga", typ: u(undefined, null) }, + { json: "Micky", js: "Micky", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "cineolic", js: "cineolic", typ: u(undefined, null) }, + { json: "cobbly", js: "cobbly", typ: u(undefined, null) }, + { json: "conchyliferous", js: "conchyliferous", typ: u(undefined, null) }, + { json: "congregation", js: "congregation", typ: u(undefined, null) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "enterotomy", js: "enterotomy", typ: u(undefined, null) }, + { json: "entophytal", js: "entophytal", typ: u(undefined, null) }, + { json: "fewtrils", js: "fewtrils", typ: u(undefined, null) }, + { json: "herem", js: "herem", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "meticulosity", js: "meticulosity", typ: u(undefined, null) }, + { json: "mismarriage", js: "mismarriage", typ: u(undefined, null) }, + { json: "neurotrophic", js: "neurotrophic", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "persuasively", js: "persuasively", typ: u(undefined, null) }, + { json: "replaceable", js: "replaceable", typ: u(undefined, null) }, + { json: "silex", js: "silex", typ: u(undefined, null) }, + { json: "taillight", js: "taillight", typ: u(undefined, null) }, + { json: "unjealous", js: "unjealous", typ: u(undefined, null) }, + { json: "visitorial", js: "visitorial", typ: u(undefined, null) }, + ], false), + "PotwhiskyClass": o([ + { json: "Euchorda", js: "Euchorda", typ: null }, + { json: "Yoruba", js: "Yoruba", typ: null }, + { json: "arciform", js: "arciform", typ: null }, + { json: "cresolin", js: "cresolin", typ: null }, + { json: "disheartener", js: "disheartener", typ: null }, + { json: "disproportionable", js: "disproportionable", typ: null }, + { json: "ferryway", js: "ferryway", typ: null }, + { json: "filamentiferous", js: "filamentiferous", typ: null }, + { json: "flemish", js: "flemish", typ: null }, + { json: "forgainst", js: "forgainst", typ: null }, + { json: "grainering", js: "grainering", typ: null }, + { json: "irrevoluble", js: "irrevoluble", typ: null }, + { json: "kindredship", js: "kindredship", typ: null }, + { json: "pinguitudinous", js: "pinguitudinous", typ: null }, + { json: "simpletonic", js: "simpletonic", typ: null }, + { json: "singsong", js: "singsong", typ: null }, + { json: "submergement", js: "submergement", typ: null }, + { json: "supraoesophagal", js: "supraoesophagal", typ: null }, + { json: "thrashel", js: "thrashel", typ: null }, + { json: "tyremesis", js: "tyremesis", typ: null }, + ], false), + "PrefreshmanClass": o([ + { json: "Dolphus", js: "Dolphus", typ: null }, + { json: "Ficus", js: "Ficus", typ: null }, + { json: "Gemaric", js: "Gemaric", typ: null }, + { json: "Phaet", js: "Phaet", typ: null }, + { json: "azorubine", js: "azorubine", typ: null }, + { json: "choroiditis", js: "choroiditis", typ: null }, + { json: "coagulatory", js: "coagulatory", typ: null }, + { json: "cyclorama", js: "cyclorama", typ: null }, + { json: "duckhearted", js: "duckhearted", typ: null }, + { json: "jugation", js: "jugation", typ: null }, + { json: "myoliposis", js: "myoliposis", typ: null }, + { json: "nonnomination", js: "nonnomination", typ: null }, + { json: "palay", js: "palay", typ: null }, + { json: "pentactinal", js: "pentactinal", typ: null }, + { json: "piquant", js: "piquant", typ: null }, + { json: "registration", js: "registration", typ: null }, + { json: "remancipation", js: "remancipation", typ: null }, + { json: "scutatiform", js: "scutatiform", typ: null }, + { json: "theodolite", js: "theodolite", typ: null }, + { json: "underward", js: "underward", typ: null }, + ], false), +}; diff --git a/head/typescript/test/inputs/json/priority/combinations3.json/prefer-types-true--df33e18681f9/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations3.json/prefer-types-true--df33e18681f9/TopLevel.ts new file mode 100644 index 0000000..bda7d9c --- /dev/null +++ b/head/typescript/test/inputs/json/priority/combinations3.json/prefer-types-true--df33e18681f9/TopLevel.ts @@ -0,0 +1,1016 @@ +// To parse this data: +// +// import { Convert, TopLevel } from "./TopLevel"; +// +// const topLevel = Convert.toTopLevel(json); +// +// These functions will throw an error if the JSON doesn't +// match the expected interface, even if the JSON is valid. + +export type TopLevel = { + juror: JurorElement[]; + kongoni: Kongoni[]; + ladronism: LadronismElement[]; + landlubberly: LandlubberlyElement[]; + listener: Listener[]; + lupus: LupusElement[]; + maslin: Maslin[]; + monazite: MonaziteElement[]; + monoliteral: Monoliteral[]; + monotheistically: MonotheisticallyElement[]; + montage: Montage[]; + moralness: Moralness[]; + mowra: (MonaziteClass | null)[]; + mulishly: Mulishly[]; + myoscope: Myoscope[]; + nach: ((number | null)[] | null)[]; + neuromastic: Neuromastic[]; + noncontributing: Noncontributing[]; + nonnervous: Nonnervous[]; + nonvaluation: Nonvaluation[]; + occupationalist: OccupationalistElement[]; + outrival: OutrivalElement[]; + paleographically: Paleographically[]; + pamphletwise: Pamphletwise[]; + pediatrics: Pediatric[]; + perceptive: boolean[]; + piaculum: PiaculumElement[]; + piccadilly: Piccadilly[]; + piffler: Piffler[]; + pithful: Pithful[]; + placuntitis: Placuntiti[]; + plectopterous: Plectopterous[]; + pneumocele: (Pneumocele | null)[]; + poliorcetic: Poliorcetic[]; + poormaster: Poormaster[]; + potwhisky: PotwhiskyElement[]; + practicalizer: Practicalizer[]; + prefreshman: PrefreshmanElement[]; + prehensility: Prehensility[]; + prevoidance: Prevoidance[]; + probant: { [key: string]: number | null }[]; + protext: Protext[]; +} + +export type JurorElement = boolean | JurorClass; + +export type JurorClass = { + Olea: null; + adipsy: null; + auxiliator: null; + benda: null; + benjamin: null; + brandling: null; + epicurishly: null; + eremochaetous: null; + marten: null; + monocline: null; + palgat: null; + pennyworth: null; + pioury: null; + pragmatistic: null; + stylelessness: null; + systematical: null; + thready: null; + uncontemporary: null; + uncouched: null; + uninhabitedness: null; +} + +export type Kongoni = number[] | { [key: string]: number }; + +export type LadronismElement = LadronismClass | number | string; + +export type LadronismClass = { + Prodenia: null; + acclaimer: null; + achree: null; + base: null; + conundrumize: null; + degerminator: null; + describable: null; + exasperatedly: null; + heroine: null; + indazin: null; + luteous: null; + papular: null; + pritch: null; + seege: null; + shopgirl: null; + tragedietta: null; + unsparse: null; + uplook: null; + vermiformis: null; + whafabout: null; +} + +export type LandlubberlyElement = boolean | LandlubberlyClass | number; + +export type LandlubberlyClass = { + Amyraldism: null; + acropoleis: null; + aminate: null; + bipenniform: null; + bugre: null; + calycule: null; + caoutchouc: null; + disprover: null; + fitroot: null; + fulgently: null; + kickup: null; + laevoversion: null; + moter: null; + objectivity: null; + posterity: null; + postnuptial: null; + precedentary: null; + saddling: null; + subcurrent: null; + unrecriminative: null; +} + +export type Listener = null[] | number; + +export type LupusElement = LupusClass | number; + +export type LupusClass = { + Chirotherium?: number; + Chlorioninae?: number; + Corvinae?: number; + Crassina?: number; + Thysanocarpus?: number; + catharticalness?: number; + disdiapason?: string; + exiguity?: number; + farcist?: number; + holographical?: number; + homocerc?: boolean; + ichthyophagan?: number; + implacable?: number; + nonbookish?: null; + outshiner?: number; + overweather?: number; + protonegroid?: number; + shallowish?: number; + snoke?: number; + snout?: number; + surveillance?: number; + threshingtime?: number; + unsignificantly?: number; + unsnap?: number; + vendible?: number; +} + +export type Maslin = { + Alicant?: number; + Bakuninist?: null; + Chirotherium?: number; + Dimitry?: number; + antiatonement?: null; + anticorrosive?: number; + aphidozer?: null; + be?: number; + catharticalness?: number; + chub?: number; + cuprosilicon?: number; + curtailedly?: number; + dellenite?: number; + disdiapason?: string; + edifying?: null; + ethmoiditis?: number; + gastralgy?: null; + goatherd?: number; + hammerdress?: number; + hangfire?: null; + homocerc?: boolean; + lacunosity?: number; + longiloquence?: null; + mameliere?: number; + motherless?: null; + nonbookish?: null; + noncorrodible?: null; + nonsensicality?: null; + oafishly?: number; + pfund?: null; + preadvisory?: null; + retroflexed?: null; + saccharulmic?: number; + scowlful?: number; + secluded?: null; + slackage?: null; + sphaeridial?: number; + spondulics?: null; + subsecive?: number; + swellmobsman?: null; + trachyglossate?: number; + trialogue?: null; + unassuaged?: number; + ungross?: null; + unjudiciously?: null; +} + +export type MonaziteElement = MonaziteClass | number; + +export type MonaziteClass = { + Chirotherium: number; + catharticalness: number; + disdiapason: string; + homocerc: boolean; + nonbookish: null; +} + +export type Monoliteral = null[] | boolean; + +export type MonotheisticallyElement = null[] | MonotheisticallyClass; + +export type MonotheisticallyClass = { + Chirotherium?: number; + blaspheme?: null; + catharticalness?: number; + celiosalpingectomy?: null; + consummativeness?: null; + disdiapason?: string; + egestive?: null; + enchylema?: null; + gasconade?: null; + holidayer?: null; + homocerc?: boolean; + intuitionalism?: null; + lophiostomate?: null; + nonbookish?: null; + nonvolition?: null; + palatableness?: null; + pimpery?: null; + previolation?: null; + reconveyance?: null; + registership?: null; + rhyacolite?: null; + smithereens?: null; + superedification?: null; + trust?: null; + whitestone?: null; +} + +export type Montage = null[] | number | string; + +export type Moralness = null[] | number | null; + +export type Mulishly = number[] | number | null; + +export type Myoscope = null[] | boolean | number; + +export type Neuromastic = null[] | number; + +export type Noncontributing = { + estevin: string; + jolterhead: number; + sauternes: number; + sparsely: boolean; + unrequested: null; +} + +export type Nonnervous = boolean | number; + +export type Nonvaluation = null[] | boolean | number; + +export type OccupationalistElement = null[] | OccupationalistClass | null; + +export type OccupationalistClass = { + Chimakum: null; + Fin: null; + beholdable: null; + brotuliform: null; + doodler: null; + emulsin: null; + flourishing: null; + flueless: null; + furtively: null; + gritter: null; + interwish: null; + monoxylic: null; + myristic: null; + nightwear: null; + peruser: null; + theoastrological: null; + thumby: null; + tingitid: null; + trailless: null; + unpocketed: null; +} + +export type OutrivalElement = OutrivalClass | number | null; + +export type OutrivalClass = { + Castoroides: null; + Czechoslovak: null; + Lingulidae: null; + adroitly: null; + bridehood: null; + diagenesis: null; + dihexahedron: null; + dopester: null; + eumerism: null; + flyness: null; + fouler: null; + laudanosine: null; + minutary: null; + mitra: null; + opisthorchiasis: null; + pensively: null; + pubigerous: null; + rebellious: null; + recodify: null; + unpaced: null; +} + +export type Paleographically = number | { [key: string]: number | null }; + +export type Pamphletwise = number | { [key: string]: number } | string; + +export type Pediatric = boolean | number | null; + +export type PiaculumElement = PiaculumClass | number; + +export type PiaculumClass = { + Chirotherium?: number; + Zipper?: number; + alada?: number; + amphistomous?: number; + boysenberry?: number; + catharticalness?: number; + decardinalize?: number; + discouragement?: number; + disdiapason?: string; + doitrified?: number; + hexaspermous?: number; + homocerc?: boolean; + insinking?: number; + loathfulness?: number; + miasmatical?: number; + neurofibril?: number; + nonbookish?: null; + phonendoscope?: number; + pilferment?: number; + predismissory?: number; + preinscription?: number; + quotative?: number; + sienna?: number; + thorax?: number; + yachting?: number; +} + +export type Piccadilly = number | null | string; + +export type Piffler = null[] | MonaziteClass; + +export type Pithful = boolean | number | null; + +export type Placuntiti = number | { [key: string]: number }; + +export type Plectopterous = number | { [key: string]: number }; + +export type Pneumocele = { + Carbonarism?: null; + Chirotherium?: number; + Koniga?: null; + Micky?: null; + catharticalness?: number; + cineolic?: null; + cobbly?: null; + conchyliferous?: null; + congregation?: null; + disdiapason?: string; + enterotomy?: null; + entophytal?: null; + fewtrils?: null; + herem?: null; + homocerc?: boolean; + meticulosity?: null; + mismarriage?: null; + neurotrophic?: null; + nonbookish?: null; + persuasively?: null; + replaceable?: null; + silex?: null; + taillight?: null; + unjealous?: null; + visitorial?: null; +} + +export type Poliorcetic = boolean | MonaziteClass; + +export type Poormaster = number[] | { [key: string]: number } | null; + +export type PotwhiskyElement = PotwhiskyClass | number | null; + +export type PotwhiskyClass = { + Euchorda: null; + Yoruba: null; + arciform: null; + cresolin: null; + disheartener: null; + disproportionable: null; + ferryway: null; + filamentiferous: null; + flemish: null; + forgainst: null; + grainering: null; + irrevoluble: null; + kindredship: null; + pinguitudinous: null; + simpletonic: null; + singsong: null; + submergement: null; + supraoesophagal: null; + thrashel: null; + tyremesis: null; +} + +export type Practicalizer = null[] | MonaziteClass | string; + +export type PrefreshmanElement = null[] | PrefreshmanClass | string; + +export type PrefreshmanClass = { + Dolphus: null; + Ficus: null; + Gemaric: null; + Phaet: null; + azorubine: null; + choroiditis: null; + coagulatory: null; + cyclorama: null; + duckhearted: null; + jugation: null; + myoliposis: null; + nonnomination: null; + palay: null; + pentactinal: null; + piquant: null; + registration: null; + remancipation: null; + scutatiform: null; + theodolite: null; + underward: null; +} + +export type Prehensility = null[] | boolean | MonaziteClass; + +export type Prevoidance = number[] | MonaziteClass | number; + +export type Protext = number[] | boolean | MonaziteClass; + +// Converts JSON strings to/from your types +// and asserts the results of JSON.parse at runtime +export class Convert { + public static toTopLevel(json: string): TopLevel { + return cast(JSON.parse(json), r("TopLevel")); + } + + public static topLevelToJson(value: TopLevel): string { + return JSON.stringify(uncast(value, r("TopLevel")), null, 2); + } +} + +function invalidValue(typ: any, val: any, key: any, parent: any = ''): never { + const prettyTyp = prettyTypeName(typ); + const parentText = parent ? ` on ${parent}` : ''; + const keyText = key ? ` for key "${key}"` : ''; + throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`); +} + +function prettyTypeName(typ: any): string { + if (Array.isArray(typ)) { + if (typ.length === 2 && typ[0] === undefined) { + return `an optional ${prettyTypeName(typ[1])}`; + } else { + return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`; + } + } else if (typeof typ === "object" && typ.literal !== undefined) { + return typ.literal; + } else { + return typeof typ; + } +} + +function jsonToJSProps(typ: any): any { + if (typ.jsonToJS === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ }); + typ.jsonToJS = map; + } + return typ.jsonToJS; +} + +function jsToJSONProps(typ: any): any { + if (typ.jsToJSON === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ }); + typ.jsToJSON = map; + } + return typ.jsToJSON; +} + +function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any { + function transformPrimitive(typ: string, val: any): any { + if (typeof typ === typeof val) return val; + return invalidValue(typ, val, key, parent); + } + + function transformUnion(typs: any[], val: any): any { + // val must validate against one typ in typs + const l = typs.length; + for (let i = 0; i < l; i++) { + const typ = typs[i]; + try { + return transform(val, typ, getProps); + } catch (_) {} + } + return invalidValue(typs, val, key, parent); + } + + function transformEnum(cases: string[], val: any): any { + if (cases.indexOf(val) !== -1) return val; + return invalidValue(cases.map(a => { return l(a); }), val, key, parent); + } + + function transformArray(typ: any, val: any): any { + // val must be an array with no invalid elements + if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent); + + return val.map(el => transform(el, typ, getProps)); + } + + function transformDate(val: any): any { + if (val === null) { + return null; + } + const d = new Date(val); + if (isNaN(d.valueOf())) { + return invalidValue(l("Date"), val, key, parent); + } + return d; + } + + function transformObject(props: { [k: string]: any }, additional: any, val: any): any { + if (val === null || typeof val !== "object" || Array.isArray(val)) { + return invalidValue(l(ref || "object"), val, key, parent); + } + const result: any = {}; + Object.getOwnPropertyNames(props).forEach(key => { + const prop = props[key]; + const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined; + result[prop.key] = transform(v, prop.typ, getProps, key, ref); + }); + Object.getOwnPropertyNames(val).forEach(key => { + if (!Object.prototype.hasOwnProperty.call(props, key)) { + result[key] = transform(val[key], additional, getProps, key, ref); + } + }); + return result; + } + + if (typ === "any") return val; + if (typ === null) { + if (val === null) return val; + return invalidValue(typ, val, key, parent); + } + if (typ === false) return invalidValue(typ, val, key, parent); + let ref: any = undefined; + while (typeof typ === "object" && typ.ref !== undefined) { + ref = typ.ref; + typ = typeMap[typ.ref]; + } + if (Array.isArray(typ)) return transformEnum(typ, val); + if (typeof typ === "object") { + return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) + : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) + : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val) + : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val) + : invalidValue(typ, val, key, parent); + } + // Numbers can be parsed by Date but shouldn't be. + if (typ === Date && typeof val !== "number") return transformDate(val); + return transformPrimitive(typ, val); +} + +function cast(val: any, typ: any): T { + return transform(val, typ, jsonToJSProps); +} + +function uncast(val: T, typ: any): any { + return transform(val, typ, jsToJSONProps); +} + +function l(typ: any) { + return { literal: typ }; +} + +function a(typ: any) { + return { arrayItems: typ }; +} + +function i(typ: any) { + return { integer: typ }; +} + +function p(pattern: any) { + return { pattern }; +} + +function s(typ: any, min: any, max: any) { + return { string: typ, min, max }; +} + +function n(typ: any, min: any, max: any) { + return { number: typ, min, max }; +} + +function u(...typs: any[]) { + return { unionMembers: typs }; +} + +function o(props: any[], additional: any) { + return { props, additional }; +} + +function m(additional: any) { + const props: any[] = []; + return { props, additional }; +} + +function r(name: string) { + return { ref: name }; +} + +const typeMap: any = { + "TopLevel": o([ + { json: "juror", js: "juror", typ: a(u(true, r("JurorClass"))) }, + { json: "kongoni", js: "kongoni", typ: a(u(a(i(0)), m(i(0)))) }, + { json: "ladronism", js: "ladronism", typ: a(u(r("LadronismClass"), 3.14, "")) }, + { json: "landlubberly", js: "landlubberly", typ: a(u(true, r("LandlubberlyClass"), i(0))) }, + { json: "listener", js: "listener", typ: a(u(a(null), i(0))) }, + { json: "lupus", js: "lupus", typ: a(u(r("LupusClass"), i(0))) }, + { json: "maslin", js: "maslin", typ: a(r("Maslin")) }, + { json: "monazite", js: "monazite", typ: a(u(r("MonaziteClass"), 3.14)) }, + { json: "monoliteral", js: "monoliteral", typ: a(u(a(null), true)) }, + { json: "monotheistically", js: "monotheistically", typ: a(u(a(null), r("MonotheisticallyClass"))) }, + { json: "montage", js: "montage", typ: a(u(a(null), 3.14, "")) }, + { json: "moralness", js: "moralness", typ: a(u(a(null), 3.14, null)) }, + { json: "mowra", js: "mowra", typ: a(u(r("MonaziteClass"), null)) }, + { json: "mulishly", js: "mulishly", typ: a(u(a(i(0)), 3.14, null)) }, + { json: "myoscope", js: "myoscope", typ: a(u(a(null), true, i(0))) }, + { json: "nach", js: "nach", typ: a(u(a(u(i(0), null)), null)) }, + { json: "neuromastic", js: "neuromastic", typ: a(u(a(null), 3.14)) }, + { json: "noncontributing", js: "noncontributing", typ: a(r("Noncontributing")) }, + { json: "nonnervous", js: "nonnervous", typ: a(u(true, i(0))) }, + { json: "nonvaluation", js: "nonvaluation", typ: a(u(a(null), true, 3.14)) }, + { json: "occupationalist", js: "occupationalist", typ: a(u(a(null), r("OccupationalistClass"), null)) }, + { json: "outrival", js: "outrival", typ: a(u(r("OutrivalClass"), 3.14, null)) }, + { json: "paleographically", js: "paleographically", typ: a(u(3.14, m(u(i(0), null)))) }, + { json: "pamphletwise", js: "pamphletwise", typ: a(u(i(0), m(i(0)), "")) }, + { json: "pediatrics", js: "pediatrics", typ: a(u(true, 3.14, null)) }, + { json: "perceptive", js: "perceptive", typ: a(true) }, + { json: "piaculum", js: "piaculum", typ: a(u(r("PiaculumClass"), 3.14)) }, + { json: "piccadilly", js: "piccadilly", typ: a(u(3.14, null, "")) }, + { json: "piffler", js: "piffler", typ: a(u(a(null), r("MonaziteClass"))) }, + { json: "pithful", js: "pithful", typ: a(u(true, i(0), null)) }, + { json: "placuntitis", js: "placuntitis", typ: a(u(i(0), m(i(0)))) }, + { json: "plectopterous", js: "plectopterous", typ: a(u(3.14, m(i(0)))) }, + { json: "pneumocele", js: "pneumocele", typ: a(u(r("Pneumocele"), null)) }, + { json: "poliorcetic", js: "poliorcetic", typ: a(u(true, r("MonaziteClass"))) }, + { json: "poormaster", js: "poormaster", typ: a(u(a(i(0)), m(i(0)), null)) }, + { json: "potwhisky", js: "potwhisky", typ: a(u(r("PotwhiskyClass"), i(0), null)) }, + { json: "practicalizer", js: "practicalizer", typ: a(u(a(null), r("MonaziteClass"), "")) }, + { json: "prefreshman", js: "prefreshman", typ: a(u(a(null), r("PrefreshmanClass"), "")) }, + { json: "prehensility", js: "prehensility", typ: a(u(a(null), true, r("MonaziteClass"))) }, + { json: "prevoidance", js: "prevoidance", typ: a(u(a(i(0)), r("MonaziteClass"), i(0))) }, + { json: "probant", js: "probant", typ: a(m(u(i(0), null))) }, + { json: "protext", js: "protext", typ: a(u(a(i(0)), true, r("MonaziteClass"))) }, + ], false), + "JurorClass": o([ + { json: "Olea", js: "Olea", typ: null }, + { json: "adipsy", js: "adipsy", typ: null }, + { json: "auxiliator", js: "auxiliator", typ: null }, + { json: "benda", js: "benda", typ: null }, + { json: "benjamin", js: "benjamin", typ: null }, + { json: "brandling", js: "brandling", typ: null }, + { json: "epicurishly", js: "epicurishly", typ: null }, + { json: "eremochaetous", js: "eremochaetous", typ: null }, + { json: "marten", js: "marten", typ: null }, + { json: "monocline", js: "monocline", typ: null }, + { json: "palgat", js: "palgat", typ: null }, + { json: "pennyworth", js: "pennyworth", typ: null }, + { json: "pioury", js: "pioury", typ: null }, + { json: "pragmatistic", js: "pragmatistic", typ: null }, + { json: "stylelessness", js: "stylelessness", typ: null }, + { json: "systematical", js: "systematical", typ: null }, + { json: "thready", js: "thready", typ: null }, + { json: "uncontemporary", js: "uncontemporary", typ: null }, + { json: "uncouched", js: "uncouched", typ: null }, + { json: "uninhabitedness", js: "uninhabitedness", typ: null }, + ], false), + "LadronismClass": o([ + { json: "Prodenia", js: "Prodenia", typ: null }, + { json: "acclaimer", js: "acclaimer", typ: null }, + { json: "achree", js: "achree", typ: null }, + { json: "base", js: "base", typ: null }, + { json: "conundrumize", js: "conundrumize", typ: null }, + { json: "degerminator", js: "degerminator", typ: null }, + { json: "describable", js: "describable", typ: null }, + { json: "exasperatedly", js: "exasperatedly", typ: null }, + { json: "heroine", js: "heroine", typ: null }, + { json: "indazin", js: "indazin", typ: null }, + { json: "luteous", js: "luteous", typ: null }, + { json: "papular", js: "papular", typ: null }, + { json: "pritch", js: "pritch", typ: null }, + { json: "seege", js: "seege", typ: null }, + { json: "shopgirl", js: "shopgirl", typ: null }, + { json: "tragedietta", js: "tragedietta", typ: null }, + { json: "unsparse", js: "unsparse", typ: null }, + { json: "uplook", js: "uplook", typ: null }, + { json: "vermiformis", js: "vermiformis", typ: null }, + { json: "whafabout", js: "whafabout", typ: null }, + ], false), + "LandlubberlyClass": o([ + { json: "Amyraldism", js: "Amyraldism", typ: null }, + { json: "acropoleis", js: "acropoleis", typ: null }, + { json: "aminate", js: "aminate", typ: null }, + { json: "bipenniform", js: "bipenniform", typ: null }, + { json: "bugre", js: "bugre", typ: null }, + { json: "calycule", js: "calycule", typ: null }, + { json: "caoutchouc", js: "caoutchouc", typ: null }, + { json: "disprover", js: "disprover", typ: null }, + { json: "fitroot", js: "fitroot", typ: null }, + { json: "fulgently", js: "fulgently", typ: null }, + { json: "kickup", js: "kickup", typ: null }, + { json: "laevoversion", js: "laevoversion", typ: null }, + { json: "moter", js: "moter", typ: null }, + { json: "objectivity", js: "objectivity", typ: null }, + { json: "posterity", js: "posterity", typ: null }, + { json: "postnuptial", js: "postnuptial", typ: null }, + { json: "precedentary", js: "precedentary", typ: null }, + { json: "saddling", js: "saddling", typ: null }, + { json: "subcurrent", js: "subcurrent", typ: null }, + { json: "unrecriminative", js: "unrecriminative", typ: null }, + ], false), + "LupusClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Chlorioninae", js: "Chlorioninae", typ: u(undefined, i(0)) }, + { json: "Corvinae", js: "Corvinae", typ: u(undefined, i(0)) }, + { json: "Crassina", js: "Crassina", typ: u(undefined, i(0)) }, + { json: "Thysanocarpus", js: "Thysanocarpus", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "exiguity", js: "exiguity", typ: u(undefined, i(0)) }, + { json: "farcist", js: "farcist", typ: u(undefined, i(0)) }, + { json: "holographical", js: "holographical", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "ichthyophagan", js: "ichthyophagan", typ: u(undefined, i(0)) }, + { json: "implacable", js: "implacable", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "outshiner", js: "outshiner", typ: u(undefined, i(0)) }, + { json: "overweather", js: "overweather", typ: u(undefined, i(0)) }, + { json: "protonegroid", js: "protonegroid", typ: u(undefined, i(0)) }, + { json: "shallowish", js: "shallowish", typ: u(undefined, i(0)) }, + { json: "snoke", js: "snoke", typ: u(undefined, i(0)) }, + { json: "snout", js: "snout", typ: u(undefined, i(0)) }, + { json: "surveillance", js: "surveillance", typ: u(undefined, i(0)) }, + { json: "threshingtime", js: "threshingtime", typ: u(undefined, i(0)) }, + { json: "unsignificantly", js: "unsignificantly", typ: u(undefined, i(0)) }, + { json: "unsnap", js: "unsnap", typ: u(undefined, i(0)) }, + { json: "vendible", js: "vendible", typ: u(undefined, i(0)) }, + ], false), + "Maslin": o([ + { json: "Alicant", js: "Alicant", typ: u(undefined, i(0)) }, + { json: "Bakuninist", js: "Bakuninist", typ: u(undefined, null) }, + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Dimitry", js: "Dimitry", typ: u(undefined, i(0)) }, + { json: "antiatonement", js: "antiatonement", typ: u(undefined, null) }, + { json: "anticorrosive", js: "anticorrosive", typ: u(undefined, i(0)) }, + { json: "aphidozer", js: "aphidozer", typ: u(undefined, null) }, + { json: "be", js: "be", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "chub", js: "chub", typ: u(undefined, i(0)) }, + { json: "cuprosilicon", js: "cuprosilicon", typ: u(undefined, i(0)) }, + { json: "curtailedly", js: "curtailedly", typ: u(undefined, i(0)) }, + { json: "dellenite", js: "dellenite", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "edifying", js: "edifying", typ: u(undefined, null) }, + { json: "ethmoiditis", js: "ethmoiditis", typ: u(undefined, i(0)) }, + { json: "gastralgy", js: "gastralgy", typ: u(undefined, null) }, + { json: "goatherd", js: "goatherd", typ: u(undefined, i(0)) }, + { json: "hammerdress", js: "hammerdress", typ: u(undefined, i(0)) }, + { json: "hangfire", js: "hangfire", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "lacunosity", js: "lacunosity", typ: u(undefined, i(0)) }, + { json: "longiloquence", js: "longiloquence", typ: u(undefined, null) }, + { json: "mameliere", js: "mameliere", typ: u(undefined, i(0)) }, + { json: "motherless", js: "motherless", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "noncorrodible", js: "noncorrodible", typ: u(undefined, null) }, + { json: "nonsensicality", js: "nonsensicality", typ: u(undefined, null) }, + { json: "oafishly", js: "oafishly", typ: u(undefined, i(0)) }, + { json: "pfund", js: "pfund", typ: u(undefined, null) }, + { json: "preadvisory", js: "preadvisory", typ: u(undefined, null) }, + { json: "retroflexed", js: "retroflexed", typ: u(undefined, null) }, + { json: "saccharulmic", js: "saccharulmic", typ: u(undefined, i(0)) }, + { json: "scowlful", js: "scowlful", typ: u(undefined, i(0)) }, + { json: "secluded", js: "secluded", typ: u(undefined, null) }, + { json: "slackage", js: "slackage", typ: u(undefined, null) }, + { json: "sphaeridial", js: "sphaeridial", typ: u(undefined, i(0)) }, + { json: "spondulics", js: "spondulics", typ: u(undefined, null) }, + { json: "subsecive", js: "subsecive", typ: u(undefined, i(0)) }, + { json: "swellmobsman", js: "swellmobsman", typ: u(undefined, null) }, + { json: "trachyglossate", js: "trachyglossate", typ: u(undefined, i(0)) }, + { json: "trialogue", js: "trialogue", typ: u(undefined, null) }, + { json: "unassuaged", js: "unassuaged", typ: u(undefined, i(0)) }, + { json: "ungross", js: "ungross", typ: u(undefined, null) }, + { json: "unjudiciously", js: "unjudiciously", typ: u(undefined, null) }, + ], false), + "MonaziteClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: i(0) }, + { json: "catharticalness", js: "catharticalness", typ: 3.14 }, + { json: "disdiapason", js: "disdiapason", typ: "" }, + { json: "homocerc", js: "homocerc", typ: true }, + { json: "nonbookish", js: "nonbookish", typ: null }, + ], false), + "MonotheisticallyClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "blaspheme", js: "blaspheme", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "celiosalpingectomy", js: "celiosalpingectomy", typ: u(undefined, null) }, + { json: "consummativeness", js: "consummativeness", typ: u(undefined, null) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "egestive", js: "egestive", typ: u(undefined, null) }, + { json: "enchylema", js: "enchylema", typ: u(undefined, null) }, + { json: "gasconade", js: "gasconade", typ: u(undefined, null) }, + { json: "holidayer", js: "holidayer", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "intuitionalism", js: "intuitionalism", typ: u(undefined, null) }, + { json: "lophiostomate", js: "lophiostomate", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "nonvolition", js: "nonvolition", typ: u(undefined, null) }, + { json: "palatableness", js: "palatableness", typ: u(undefined, null) }, + { json: "pimpery", js: "pimpery", typ: u(undefined, null) }, + { json: "previolation", js: "previolation", typ: u(undefined, null) }, + { json: "reconveyance", js: "reconveyance", typ: u(undefined, null) }, + { json: "registership", js: "registership", typ: u(undefined, null) }, + { json: "rhyacolite", js: "rhyacolite", typ: u(undefined, null) }, + { json: "smithereens", js: "smithereens", typ: u(undefined, null) }, + { json: "superedification", js: "superedification", typ: u(undefined, null) }, + { json: "trust", js: "trust", typ: u(undefined, null) }, + { json: "whitestone", js: "whitestone", typ: u(undefined, null) }, + ], false), + "Noncontributing": o([ + { json: "estevin", js: "estevin", typ: "" }, + { json: "jolterhead", js: "jolterhead", typ: 3.14 }, + { json: "sauternes", js: "sauternes", typ: i(0) }, + { json: "sparsely", js: "sparsely", typ: true }, + { json: "unrequested", js: "unrequested", typ: null }, + ], false), + "OccupationalistClass": o([ + { json: "Chimakum", js: "Chimakum", typ: null }, + { json: "Fin", js: "Fin", typ: null }, + { json: "beholdable", js: "beholdable", typ: null }, + { json: "brotuliform", js: "brotuliform", typ: null }, + { json: "doodler", js: "doodler", typ: null }, + { json: "emulsin", js: "emulsin", typ: null }, + { json: "flourishing", js: "flourishing", typ: null }, + { json: "flueless", js: "flueless", typ: null }, + { json: "furtively", js: "furtively", typ: null }, + { json: "gritter", js: "gritter", typ: null }, + { json: "interwish", js: "interwish", typ: null }, + { json: "monoxylic", js: "monoxylic", typ: null }, + { json: "myristic", js: "myristic", typ: null }, + { json: "nightwear", js: "nightwear", typ: null }, + { json: "peruser", js: "peruser", typ: null }, + { json: "theoastrological", js: "theoastrological", typ: null }, + { json: "thumby", js: "thumby", typ: null }, + { json: "tingitid", js: "tingitid", typ: null }, + { json: "trailless", js: "trailless", typ: null }, + { json: "unpocketed", js: "unpocketed", typ: null }, + ], false), + "OutrivalClass": o([ + { json: "Castoroides", js: "Castoroides", typ: null }, + { json: "Czechoslovak", js: "Czechoslovak", typ: null }, + { json: "Lingulidae", js: "Lingulidae", typ: null }, + { json: "adroitly", js: "adroitly", typ: null }, + { json: "bridehood", js: "bridehood", typ: null }, + { json: "diagenesis", js: "diagenesis", typ: null }, + { json: "dihexahedron", js: "dihexahedron", typ: null }, + { json: "dopester", js: "dopester", typ: null }, + { json: "eumerism", js: "eumerism", typ: null }, + { json: "flyness", js: "flyness", typ: null }, + { json: "fouler", js: "fouler", typ: null }, + { json: "laudanosine", js: "laudanosine", typ: null }, + { json: "minutary", js: "minutary", typ: null }, + { json: "mitra", js: "mitra", typ: null }, + { json: "opisthorchiasis", js: "opisthorchiasis", typ: null }, + { json: "pensively", js: "pensively", typ: null }, + { json: "pubigerous", js: "pubigerous", typ: null }, + { json: "rebellious", js: "rebellious", typ: null }, + { json: "recodify", js: "recodify", typ: null }, + { json: "unpaced", js: "unpaced", typ: null }, + ], false), + "PiaculumClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Zipper", js: "Zipper", typ: u(undefined, i(0)) }, + { json: "alada", js: "alada", typ: u(undefined, i(0)) }, + { json: "amphistomous", js: "amphistomous", typ: u(undefined, i(0)) }, + { json: "boysenberry", js: "boysenberry", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "decardinalize", js: "decardinalize", typ: u(undefined, i(0)) }, + { json: "discouragement", js: "discouragement", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "doitrified", js: "doitrified", typ: u(undefined, i(0)) }, + { json: "hexaspermous", js: "hexaspermous", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "insinking", js: "insinking", typ: u(undefined, i(0)) }, + { json: "loathfulness", js: "loathfulness", typ: u(undefined, i(0)) }, + { json: "miasmatical", js: "miasmatical", typ: u(undefined, i(0)) }, + { json: "neurofibril", js: "neurofibril", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "phonendoscope", js: "phonendoscope", typ: u(undefined, i(0)) }, + { json: "pilferment", js: "pilferment", typ: u(undefined, i(0)) }, + { json: "predismissory", js: "predismissory", typ: u(undefined, i(0)) }, + { json: "preinscription", js: "preinscription", typ: u(undefined, i(0)) }, + { json: "quotative", js: "quotative", typ: u(undefined, i(0)) }, + { json: "sienna", js: "sienna", typ: u(undefined, i(0)) }, + { json: "thorax", js: "thorax", typ: u(undefined, i(0)) }, + { json: "yachting", js: "yachting", typ: u(undefined, i(0)) }, + ], false), + "Pneumocele": o([ + { json: "Carbonarism", js: "Carbonarism", typ: u(undefined, null) }, + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Koniga", js: "Koniga", typ: u(undefined, null) }, + { json: "Micky", js: "Micky", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "cineolic", js: "cineolic", typ: u(undefined, null) }, + { json: "cobbly", js: "cobbly", typ: u(undefined, null) }, + { json: "conchyliferous", js: "conchyliferous", typ: u(undefined, null) }, + { json: "congregation", js: "congregation", typ: u(undefined, null) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "enterotomy", js: "enterotomy", typ: u(undefined, null) }, + { json: "entophytal", js: "entophytal", typ: u(undefined, null) }, + { json: "fewtrils", js: "fewtrils", typ: u(undefined, null) }, + { json: "herem", js: "herem", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "meticulosity", js: "meticulosity", typ: u(undefined, null) }, + { json: "mismarriage", js: "mismarriage", typ: u(undefined, null) }, + { json: "neurotrophic", js: "neurotrophic", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "persuasively", js: "persuasively", typ: u(undefined, null) }, + { json: "replaceable", js: "replaceable", typ: u(undefined, null) }, + { json: "silex", js: "silex", typ: u(undefined, null) }, + { json: "taillight", js: "taillight", typ: u(undefined, null) }, + { json: "unjealous", js: "unjealous", typ: u(undefined, null) }, + { json: "visitorial", js: "visitorial", typ: u(undefined, null) }, + ], false), + "PotwhiskyClass": o([ + { json: "Euchorda", js: "Euchorda", typ: null }, + { json: "Yoruba", js: "Yoruba", typ: null }, + { json: "arciform", js: "arciform", typ: null }, + { json: "cresolin", js: "cresolin", typ: null }, + { json: "disheartener", js: "disheartener", typ: null }, + { json: "disproportionable", js: "disproportionable", typ: null }, + { json: "ferryway", js: "ferryway", typ: null }, + { json: "filamentiferous", js: "filamentiferous", typ: null }, + { json: "flemish", js: "flemish", typ: null }, + { json: "forgainst", js: "forgainst", typ: null }, + { json: "grainering", js: "grainering", typ: null }, + { json: "irrevoluble", js: "irrevoluble", typ: null }, + { json: "kindredship", js: "kindredship", typ: null }, + { json: "pinguitudinous", js: "pinguitudinous", typ: null }, + { json: "simpletonic", js: "simpletonic", typ: null }, + { json: "singsong", js: "singsong", typ: null }, + { json: "submergement", js: "submergement", typ: null }, + { json: "supraoesophagal", js: "supraoesophagal", typ: null }, + { json: "thrashel", js: "thrashel", typ: null }, + { json: "tyremesis", js: "tyremesis", typ: null }, + ], false), + "PrefreshmanClass": o([ + { json: "Dolphus", js: "Dolphus", typ: null }, + { json: "Ficus", js: "Ficus", typ: null }, + { json: "Gemaric", js: "Gemaric", typ: null }, + { json: "Phaet", js: "Phaet", typ: null }, + { json: "azorubine", js: "azorubine", typ: null }, + { json: "choroiditis", js: "choroiditis", typ: null }, + { json: "coagulatory", js: "coagulatory", typ: null }, + { json: "cyclorama", js: "cyclorama", typ: null }, + { json: "duckhearted", js: "duckhearted", typ: null }, + { json: "jugation", js: "jugation", typ: null }, + { json: "myoliposis", js: "myoliposis", typ: null }, + { json: "nonnomination", js: "nonnomination", typ: null }, + { json: "palay", js: "palay", typ: null }, + { json: "pentactinal", js: "pentactinal", typ: null }, + { json: "piquant", js: "piquant", typ: null }, + { json: "registration", js: "registration", typ: null }, + { json: "remancipation", js: "remancipation", typ: null }, + { json: "scutatiform", js: "scutatiform", typ: null }, + { json: "theodolite", js: "theodolite", typ: null }, + { json: "underward", js: "underward", typ: null }, + ], false), +}; diff --git a/base/typescript/test/inputs/json/priority/combinations3.json/prefer-unions-false--a5053c0a486d/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations3.json/prefer-unions-false--a5053c0a486d/TopLevel.ts index e726dc5..91fda79 100644 --- a/base/typescript/test/inputs/json/priority/combinations3.json/prefer-unions-false--a5053c0a486d/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations3.json/prefer-unions-false--a5053c0a486d/TopLevel.ts @@ -583,7 +583,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations3.json/prefer-unknown-false--f1ab9e45d823/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations3.json/prefer-unknown-false--f1ab9e45d823/TopLevel.ts index e726dc5..91fda79 100644 --- a/base/typescript/test/inputs/json/priority/combinations3.json/prefer-unknown-false--f1ab9e45d823/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations3.json/prefer-unknown-false--f1ab9e45d823/TopLevel.ts @@ -583,7 +583,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations3.json/readonly-true--24da4fc107df/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations3.json/readonly-true--24da4fc107df/TopLevel.ts index d74d207..682231e 100644 --- a/base/typescript/test/inputs/json/priority/combinations3.json/readonly-true--24da4fc107df/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations3.json/readonly-true--24da4fc107df/TopLevel.ts @@ -583,7 +583,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations3.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations3.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.ts index fa4dd36..346b59c 100644 --- a/base/typescript/test/inputs/json/priority/combinations3.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations3.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.ts @@ -583,7 +583,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations4.json/acronym-style-pascal--d9e0c1bd777a/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations4.json/acronym-style-pascal--d9e0c1bd777a/TopLevel.ts index bcc98d6..45c706b 100644 --- a/base/typescript/test/inputs/json/priority/combinations4.json/acronym-style-pascal--d9e0c1bd777a/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations4.json/acronym-style-pascal--d9e0c1bd777a/TopLevel.ts @@ -653,7 +653,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations4.json/converters-all-objects--3a443babd1cb/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations4.json/converters-all-objects--3a443babd1cb/TopLevel.ts index 880e87a..7a91ed4 100644 --- a/base/typescript/test/inputs/json/priority/combinations4.json/converters-all-objects--3a443babd1cb/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations4.json/converters-all-objects--3a443babd1cb/TopLevel.ts @@ -781,7 +781,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations4.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations4.json/default/TopLevel.ts index bcc98d6..45c706b 100644 --- a/base/typescript/test/inputs/json/priority/combinations4.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations4.json/default/TopLevel.ts @@ -653,7 +653,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations4.json/nice-property-names-true--f4d7920ee2ce/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations4.json/nice-property-names-true--f4d7920ee2ce/TopLevel.ts index 998f2fa..86c59b2 100644 --- a/base/typescript/test/inputs/json/priority/combinations4.json/nice-property-names-true--f4d7920ee2ce/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations4.json/nice-property-names-true--f4d7920ee2ce/TopLevel.ts @@ -653,7 +653,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/head/typescript/test/inputs/json/priority/combinations4.json/prefer-const-values-true--6b26e4d1265c/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations4.json/prefer-const-values-true--6b26e4d1265c/TopLevel.ts new file mode 100644 index 0000000..45c706b --- /dev/null +++ b/head/typescript/test/inputs/json/priority/combinations4.json/prefer-const-values-true--6b26e4d1265c/TopLevel.ts @@ -0,0 +1,1140 @@ +// To parse this data: +// +// import { Convert, TopLevel } from "./TopLevel"; +// +// const topLevel = Convert.toTopLevel(json); +// +// These functions will throw an error if the JSON doesn't +// match the expected interface, even if the JSON is valid. + +export interface TopLevel { + protrusive: Protrusive[]; + pulpitism: PulpitismElement[]; + pyodermia: PyodermiaElement[]; + quebrachine: QuebrachineElement[]; + querier: Querier[]; + rebarbative: Rebarbative[]; + reimagine: Reimagine[]; + ressaut: Ressaut; + retrocervical: Retrocervical[]; + revert: Revert[]; + rewrite: RewriteElement[]; + saccoderm: Saccoderm[]; + santir: SantirElement[]; + saprophilous: Saprophilous[]; + saxten: SaxtenElement[]; + scatty: (Scatty | null)[]; + scoffer: Scoffer[]; + scrampum: Scrampum[]; + semantic: number; + serpentinic: Serpentinic[]; + shadowable: Shadowable[]; + sistering: SisteringElement[]; + staghunting: Staghunting[]; + stagmometer: Stagmometer[]; + stimulability: Stimulability[]; + strangleable: Strangleable[]; + strenuosity: StrenuosityElement[]; + tabaxir: Tabaxir[]; + talpiform: Talpiform[]; + thwack: Thwack[]; + to: (number | null)[]; + tortricine: Tortricine[]; + truantcy: TruantcyElement[]; + turgesce: string[]; + unbeginning: Unbeginning[]; + underdunged: number[]; + undesirability: Undesirability[]; + unerasing: Unerasing[]; + unguentarium: Unguentarium[]; + unimpeachably: UnimpeachablyElement[]; + unmortgaged: Unmortgaged[]; + unobstructed: Unobstructed[]; + unreceptivity: Unreceptivity[]; + unsatisfactoriness: Unsatisfactoriness[]; + unsecurity: number[]; + unstressed: UnstressedElement[]; + untasked: Untasked[]; + unvarying: Unvarying[]; + vehemently: Vehemently[]; + warriorship: { [key: string]: boolean }; + whitepot: Whitepot[]; + wrothy: WrothyElement[]; +} + +export type Protrusive = (number | null)[] | number; + +export type PulpitismElement = number[] | PulpitismClass | number; + +export interface PulpitismClass { + abnet: null; + buckhorn: null; + calciform: null; + chelophore: null; + cogitation: null; + decreeable: null; + despicable: null; + isodiazo: null; + jadedly: null; + leptochlorite: null; + nursling: null; + palamedean: null; + photoheliograph: null; + pipewood: null; + roberd: null; + statable: null; + superassume: null; + syllabe: null; + toughhead: null; + underburn: null; +} + +export type PyodermiaElement = PyodermiaClass | number; + +export interface PyodermiaClass { + Gyppo: null; + aphoristically: null; + apophyllous: null; + cognize: null; + dermonosology: null; + ither: null; + juglandaceous: null; + litho: null; + macropterous: null; + photographer: null; + romancing: null; + rumness: null; + somniloquist: null; + stressfully: null; + tactically: null; + tracheophony: null; + unappositely: null; + unclothedly: null; + unimplied: null; + unsyncopated: null; +} + +export type QuebrachineElement = boolean | QuebrachineClass | null; + +export interface QuebrachineClass { + Chirotherium: number; + catharticalness: number; + disdiapason: string; + homocerc: boolean; + nonbookish: null; +} + +export type Querier = boolean | { [key: string]: number }; + +export type Rebarbative = number[] | boolean | number; + +export interface Reimagine { + Chirotherium?: number; + Hermo?: null; + adducible?: null; + anabolin?: null; + brainy?: null; + catharticalness?: number; + chrysamine?: null; + disdiapason?: string; + fluxweed?: null; + glaucine?: null; + grobianism?: null; + hieroglyphist?: null; + homocerc?: boolean; + icteroid?: null; + immortal?: null; + impetulant?: null; + irrigate?: null; + myxedema?: null; + nonbookish?: null; + onyx?: null; + repasser?: null; + septomarginal?: null; + subdie?: null; + tibiometatarsal?: null; + waltzlike?: null; +} + +export interface Ressaut { + Freesia: string; + Genevieve: string; + Mimosaceae: string; + Theopaschitism: string; + apperceptive: string; + cuttoo: string; + douser: string; + drinkproof: string; + forementioned: string; + hyperdiabolical: string; + hypocone: string; + irreverentially: string; + jumart: string; + mollicrush: string; + nedder: string; + retinasphalt: string; + sough: string; + steading: string; + undurableness: string; + unmingleable: string; +} + +export type Retrocervical = (number | null)[] | number; + +export type Revert = boolean | string; + +export type RewriteElement = null[] | RewriteClass | number; + +export interface RewriteClass { + Hyades: null; + Ptenoglossa: null; + Whiggification: null; + accountancy: null; + cacotrophic: null; + contest: null; + couthily: null; + falculate: null; + foreseize: null; + lemnad: null; + monotheistically: null; + nonflying: null; + repatch: null; + rodman: null; + strung: null; + titmal: null; + twalpennyworth: null; + unblamable: null; + vertical: null; + yardman: null; +} + +export type Saccoderm = number[] | null | string; + +export type SantirElement = SantirClass | number; + +export interface SantirClass { + Suessiones: null; + admiredly: null; + demicaponier: null; + epitympanic: null; + investitor: null; + lupiform: null; + monoflagellate: null; + paleoethnic: null; + prediscountable: null; + rhetoricals: null; + roomth: null; + saccharose: null; + septonasal: null; + serpenticide: null; + setarious: null; + spaework: null; + stylite: null; + timelily: null; + unprofaned: null; + vorticular: null; +} + +export type Saprophilous = { [key: string]: number } | null | string; + +export type SaxtenElement = SaxtenClass | string; + +export interface SaxtenClass { + Centaurid?: null; + Chirotherium?: number; + algarrobilla?: null; + bowgrace?: null; + catharticalness?: number; + disdiapason?: string; + flix?: null; + germanely?: null; + homocerc?: boolean; + inhume?: null; + lepidote?: null; + megalochirous?: null; + ninepenny?: null; + nonbookish?: null; + nondeist?: null; + nymphaeaceous?: null; + parietofrontal?: null; + sancyite?: null; + subjectivist?: null; + tibiad?: null; + transonic?: null; + tripetalous?: null; + trunchman?: null; + urger?: null; + withdrawnness?: null; +} + +export interface Scatty { + Tabasco: null; + aeriferous: null; + antical: null; + antighostism: null; + arcanum: null; + autotrophy: null; + baronial: null; + caffeine: null; + gorgoniacean: null; + heroical: null; + hydropical: null; + mechanology: null; + musicopoetic: null; + officiality: null; + oftentimes: null; + ophthalmotonometer: null; + reflectively: null; + springer: null; + teleianthous: null; + uncombated: null; +} + +export type Scoffer = null[] | { [key: string]: number } | null; + +export type Scrampum = number[] | boolean | null; + +export type Serpentinic = number[] | number; + +export type Shadowable = (number | null)[] | boolean; + +export type SisteringElement = null[] | SisteringClass | number; + +export interface SisteringClass { + Chianti: null; + Haplomi: null; + Micropterygidae: null; + amphicarpic: null; + frigorific: null; + hyperkinesis: null; + laudable: null; + madwoman: null; + maimedly: null; + microrhabdus: null; + nondense: null; + phlebemphraxis: null; + redsear: null; + schismatical: null; + tartryl: null; + unabhorred: null; + undeliberateness: null; + unmixable: null; + untruckling: null; + vineal: null; +} + +export interface Staghunting { + Chirotherium?: number; + calorimetric?: number; + canid?: number; + catharticalness?: number; + disdiapason?: string; + ditriglyphic?: number; + floriferousness?: number; + gamelike?: number; + grig?: number; + homocerc?: boolean; + interloan?: number; + lithotomy?: number; + loric?: number; + membranocoriaceous?: number; + membranogenic?: number; + nonbookish?: null; + overtrump?: number; + scotino?: number; + seasonable?: number; + sephen?: number; + stigmarioid?: number; + tired?: number; + trifid?: number; + undefeatedly?: number; + ungirlish?: number; +} + +export type Stagmometer = (number | null)[] | string; + +export type Stimulability = boolean | number | { [key: string]: number }; + +export type Strangleable = null[] | number; + +export type StrenuosityElement = null[] | StrenuosityClass; + +export interface StrenuosityClass { + Chirotherium?: number; + Onopordon?: number; + Sodomite?: number; + Yankeeist?: number; + bliss?: number; + buccate?: number; + bulletproof?: number; + catharticalness?: number; + crumblingness?: number; + disdiapason?: string; + engagedly?: number; + fightable?: number; + hoariness?: number; + homocerc?: boolean; + hypopodium?: number; + luxurist?: number; + mechanician?: number; + nonbookish?: null; + podgily?: number; + reformableness?: number; + scatterbrains?: number; + seminuria?: number; + tramp?: number; + undueness?: number; + worthily?: number; +} + +export type Tabaxir = boolean | number; + +export type Talpiform = QuebrachineClass | number | null; + +export type Thwack = boolean | QuebrachineClass | number; + +export type Tortricine = (number | null)[] | QuebrachineClass; + +export type TruantcyElement = boolean | TruantcyClass; + +export interface TruantcyClass { + Chirotherium?: number; + Epeira?: null; + Eurylaimi?: null; + Yuman?: null; + alfiona?: null; + ascaridiasis?: null; + bungey?: null; + catharticalness?: number; + ceroxyle?: null; + chorology?: null; + disdiapason?: string; + enmarble?: null; + germination?: null; + hallelujah?: null; + homocerc?: boolean; + lev?: null; + mouthing?: null; + nonbookish?: null; + philliloo?: null; + planetal?: null; + poney?: null; + punctualist?: null; + returnlessly?: null; + skelder?: null; + windwaywardly?: null; +} + +export type Unbeginning = null[] | { [key: string]: number } | string; + +export type Undesirability = number[] | { [key: string]: number } | string; + +export type Unerasing = null[] | number | { [key: string]: number }; + +export type Unguentarium = null[] | number | null; + +export type UnimpeachablyElement = boolean | UnimpeachablyClass; + +export interface UnimpeachablyClass { + Bobadil?: number; + Chirotherium?: number; + Quiina?: number; + Robert?: number; + acerin?: number; + catharticalness?: number; + chlorophylligenous?: number; + conversational?: number; + demiowl?: number; + disdiapason?: string; + ectorhinal?: number; + gamblesomeness?: number; + homocerc?: boolean; + irrorate?: number; + kindergartening?: number; + lateritic?: number; + mespil?: number; + misconfiguration?: number; + nonbookish?: null; + planometry?: number; + rot?: number; + subcinctorium?: number; + tussocker?: number; + ultraproud?: number; + unsuggestedness?: number; +} + +export type Unmortgaged = number | { [key: string]: number } | null; + +export type Unobstructed = QuebrachineClass | number | null; + +export type Unreceptivity = null[] | number | string; + +export type Unsatisfactoriness = number[] | boolean | number; + +export type UnstressedElement = boolean | UnstressedClass | string; + +export interface UnstressedClass { + Alain: null; + Amphirhina: null; + Lincolnian: null; + Sarcophilus: null; + antimachinery: null; + coldish: null; + crantara: null; + distinguishing: null; + elytroposis: null; + gentianwort: null; + heliosis: null; + instrumental: null; + introinflection: null; + kala: null; + metad: null; + swingingly: null; + unconformity: null; + undecreed: null; + venerable: null; + vowellessness: null; +} + +export type Untasked = null[] | number | { [key: string]: number }; + +export type Unvarying = boolean | number | { [key: string]: number }; + +export type Vehemently = null[] | boolean | null; + +export type Whitepot = QuebrachineClass | number; + +export type WrothyElement = null[] | WrothyClass; + +export interface WrothyClass { + Aeschynanthus: null; + Ephesine: null; + aquiferous: null; + cheapener: null; + enumeration: null; + escadrille: null; + estrous: null; + interestedly: null; + katakinetomer: null; + mortification: null; + morula: null; + orthosymmetrical: null; + overbark: null; + politist: null; + qualified: null; + sphenomalar: null; + throatful: null; + transhumance: null; + triandrian: null; + unbooked: null; +} + +// Converts JSON strings to/from your types +// and asserts the results of JSON.parse at runtime +export class Convert { + public static toTopLevel(json: string): TopLevel { + return cast(JSON.parse(json), r("TopLevel")); + } + + public static topLevelToJson(value: TopLevel): string { + return JSON.stringify(uncast(value, r("TopLevel")), null, 2); + } +} + +function invalidValue(typ: any, val: any, key: any, parent: any = ''): never { + const prettyTyp = prettyTypeName(typ); + const parentText = parent ? ` on ${parent}` : ''; + const keyText = key ? ` for key "${key}"` : ''; + throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`); +} + +function prettyTypeName(typ: any): string { + if (Array.isArray(typ)) { + if (typ.length === 2 && typ[0] === undefined) { + return `an optional ${prettyTypeName(typ[1])}`; + } else { + return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`; + } + } else if (typeof typ === "object" && typ.literal !== undefined) { + return typ.literal; + } else { + return typeof typ; + } +} + +function jsonToJSProps(typ: any): any { + if (typ.jsonToJS === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ }); + typ.jsonToJS = map; + } + return typ.jsonToJS; +} + +function jsToJSONProps(typ: any): any { + if (typ.jsToJSON === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ }); + typ.jsToJSON = map; + } + return typ.jsToJSON; +} + +function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any { + function transformPrimitive(typ: string, val: any): any { + if (typeof typ === typeof val) return val; + return invalidValue(typ, val, key, parent); + } + + function transformUnion(typs: any[], val: any): any { + // val must validate against one typ in typs + const l = typs.length; + for (let i = 0; i < l; i++) { + const typ = typs[i]; + try { + return transform(val, typ, getProps); + } catch (_) {} + } + return invalidValue(typs, val, key, parent); + } + + function transformEnum(cases: string[], val: any): any { + if (cases.indexOf(val) !== -1) return val; + return invalidValue(cases.map(a => { return l(a); }), val, key, parent); + } + + function transformArray(typ: any, val: any): any { + // val must be an array with no invalid elements + if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent); + + return val.map(el => transform(el, typ, getProps)); + } + + function transformDate(val: any): any { + if (val === null) { + return null; + } + const d = new Date(val); + if (isNaN(d.valueOf())) { + return invalidValue(l("Date"), val, key, parent); + } + return d; + } + + function transformObject(props: { [k: string]: any }, additional: any, val: any): any { + if (val === null || typeof val !== "object" || Array.isArray(val)) { + return invalidValue(l(ref || "object"), val, key, parent); + } + const result: any = {}; + Object.getOwnPropertyNames(props).forEach(key => { + const prop = props[key]; + const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined; + result[prop.key] = transform(v, prop.typ, getProps, key, ref); + }); + Object.getOwnPropertyNames(val).forEach(key => { + if (!Object.prototype.hasOwnProperty.call(props, key)) { + result[key] = transform(val[key], additional, getProps, key, ref); + } + }); + return result; + } + + if (typ === "any") return val; + if (typ === null) { + if (val === null) return val; + return invalidValue(typ, val, key, parent); + } + if (typ === false) return invalidValue(typ, val, key, parent); + let ref: any = undefined; + while (typeof typ === "object" && typ.ref !== undefined) { + ref = typ.ref; + typ = typeMap[typ.ref]; + } + if (Array.isArray(typ)) return transformEnum(typ, val); + if (typeof typ === "object") { + return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) + : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) + : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val) + : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val) + : invalidValue(typ, val, key, parent); + } + // Numbers can be parsed by Date but shouldn't be. + if (typ === Date && typeof val !== "number") return transformDate(val); + return transformPrimitive(typ, val); +} + +function cast(val: any, typ: any): T { + return transform(val, typ, jsonToJSProps); +} + +function uncast(val: T, typ: any): any { + return transform(val, typ, jsToJSONProps); +} + +function l(typ: any) { + return { literal: typ }; +} + +function a(typ: any) { + return { arrayItems: typ }; +} + +function i(typ: any) { + return { integer: typ }; +} + +function p(pattern: any) { + return { pattern }; +} + +function s(typ: any, min: any, max: any) { + return { string: typ, min, max }; +} + +function n(typ: any, min: any, max: any) { + return { number: typ, min, max }; +} + +function u(...typs: any[]) { + return { unionMembers: typs }; +} + +function o(props: any[], additional: any) { + return { props, additional }; +} + +function m(additional: any) { + const props: any[] = []; + return { props, additional }; +} + +function r(name: string) { + return { ref: name }; +} + +const typeMap: any = { + "TopLevel": o([ + { json: "protrusive", js: "protrusive", typ: a(u(a(u(i(0), null)), 3.14)) }, + { json: "pulpitism", js: "pulpitism", typ: a(u(a(i(0)), r("PulpitismClass"), 3.14)) }, + { json: "pyodermia", js: "pyodermia", typ: a(u(r("PyodermiaClass"), i(0))) }, + { json: "quebrachine", js: "quebrachine", typ: a(u(true, r("QuebrachineClass"), null)) }, + { json: "querier", js: "querier", typ: a(u(true, m(i(0)))) }, + { json: "rebarbative", js: "rebarbative", typ: a(u(a(i(0)), true, 3.14)) }, + { json: "reimagine", js: "reimagine", typ: a(r("Reimagine")) }, + { json: "ressaut", js: "ressaut", typ: r("Ressaut") }, + { json: "retrocervical", js: "retrocervical", typ: a(u(a(u(i(0), null)), i(0))) }, + { json: "revert", js: "revert", typ: a(u(true, "")) }, + { json: "rewrite", js: "rewrite", typ: a(u(a(null), r("RewriteClass"), 3.14)) }, + { json: "saccoderm", js: "saccoderm", typ: a(u(a(i(0)), null, "")) }, + { json: "santir", js: "santir", typ: a(u(r("SantirClass"), 3.14)) }, + { json: "saprophilous", js: "saprophilous", typ: a(u(m(i(0)), null, "")) }, + { json: "saxten", js: "saxten", typ: a(u(r("SaxtenClass"), "")) }, + { json: "scatty", js: "scatty", typ: a(u(r("Scatty"), null)) }, + { json: "scoffer", js: "scoffer", typ: a(u(a(null), m(i(0)), null)) }, + { json: "scrampum", js: "scrampum", typ: a(u(a(i(0)), true, null)) }, + { json: "semantic", js: "semantic", typ: 3.14 }, + { json: "serpentinic", js: "serpentinic", typ: a(u(a(i(0)), 3.14)) }, + { json: "shadowable", js: "shadowable", typ: a(u(a(u(i(0), null)), true)) }, + { json: "sistering", js: "sistering", typ: a(u(a(null), r("SisteringClass"), i(0))) }, + { json: "staghunting", js: "staghunting", typ: a(r("Staghunting")) }, + { json: "stagmometer", js: "stagmometer", typ: a(u(a(u(i(0), null)), "")) }, + { json: "stimulability", js: "stimulability", typ: a(u(true, i(0), m(i(0)))) }, + { json: "strangleable", js: "strangleable", typ: a(u(a(null), 3.14)) }, + { json: "strenuosity", js: "strenuosity", typ: a(u(a(null), r("StrenuosityClass"))) }, + { json: "tabaxir", js: "tabaxir", typ: a(u(true, 3.14)) }, + { json: "talpiform", js: "talpiform", typ: a(u(r("QuebrachineClass"), 3.14, null)) }, + { json: "thwack", js: "thwack", typ: a(u(true, r("QuebrachineClass"), 3.14)) }, + { json: "to", js: "to", typ: a(u(3.14, null)) }, + { json: "tortricine", js: "tortricine", typ: a(u(a(u(i(0), null)), r("QuebrachineClass"))) }, + { json: "truantcy", js: "truantcy", typ: a(u(true, r("TruantcyClass"))) }, + { json: "turgesce", js: "turgesce", typ: a("") }, + { json: "unbeginning", js: "unbeginning", typ: a(u(a(null), m(i(0)), "")) }, + { json: "underdunged", js: "underdunged", typ: a(3.14) }, + { json: "undesirability", js: "undesirability", typ: a(u(a(i(0)), m(i(0)), "")) }, + { json: "unerasing", js: "unerasing", typ: a(u(a(null), i(0), m(i(0)))) }, + { json: "unguentarium", js: "unguentarium", typ: a(u(a(null), i(0), null)) }, + { json: "unimpeachably", js: "unimpeachably", typ: a(u(true, r("UnimpeachablyClass"))) }, + { json: "unmortgaged", js: "unmortgaged", typ: a(u(3.14, m(i(0)), null)) }, + { json: "unobstructed", js: "unobstructed", typ: a(u(r("QuebrachineClass"), i(0), null)) }, + { json: "unreceptivity", js: "unreceptivity", typ: a(u(a(null), i(0), "")) }, + { json: "unsatisfactoriness", js: "unsatisfactoriness", typ: a(u(a(i(0)), true, i(0))) }, + { json: "unsecurity", js: "unsecurity", typ: a(i(0)) }, + { json: "unstressed", js: "unstressed", typ: a(u(true, r("UnstressedClass"), "")) }, + { json: "untasked", js: "untasked", typ: a(u(a(null), 3.14, m(i(0)))) }, + { json: "unvarying", js: "unvarying", typ: a(u(true, 3.14, m(i(0)))) }, + { json: "vehemently", js: "vehemently", typ: a(u(a(null), true, null)) }, + { json: "warriorship", js: "warriorship", typ: m(true) }, + { json: "whitepot", js: "whitepot", typ: a(u(r("QuebrachineClass"), 3.14)) }, + { json: "wrothy", js: "wrothy", typ: a(u(a(null), r("WrothyClass"))) }, + ], false), + "PulpitismClass": o([ + { json: "abnet", js: "abnet", typ: null }, + { json: "buckhorn", js: "buckhorn", typ: null }, + { json: "calciform", js: "calciform", typ: null }, + { json: "chelophore", js: "chelophore", typ: null }, + { json: "cogitation", js: "cogitation", typ: null }, + { json: "decreeable", js: "decreeable", typ: null }, + { json: "despicable", js: "despicable", typ: null }, + { json: "isodiazo", js: "isodiazo", typ: null }, + { json: "jadedly", js: "jadedly", typ: null }, + { json: "leptochlorite", js: "leptochlorite", typ: null }, + { json: "nursling", js: "nursling", typ: null }, + { json: "palamedean", js: "palamedean", typ: null }, + { json: "photoheliograph", js: "photoheliograph", typ: null }, + { json: "pipewood", js: "pipewood", typ: null }, + { json: "roberd", js: "roberd", typ: null }, + { json: "statable", js: "statable", typ: null }, + { json: "superassume", js: "superassume", typ: null }, + { json: "syllabe", js: "syllabe", typ: null }, + { json: "toughhead", js: "toughhead", typ: null }, + { json: "underburn", js: "underburn", typ: null }, + ], false), + "PyodermiaClass": o([ + { json: "Gyppo", js: "Gyppo", typ: null }, + { json: "aphoristically", js: "aphoristically", typ: null }, + { json: "apophyllous", js: "apophyllous", typ: null }, + { json: "cognize", js: "cognize", typ: null }, + { json: "dermonosology", js: "dermonosology", typ: null }, + { json: "ither", js: "ither", typ: null }, + { json: "juglandaceous", js: "juglandaceous", typ: null }, + { json: "litho", js: "litho", typ: null }, + { json: "macropterous", js: "macropterous", typ: null }, + { json: "photographer", js: "photographer", typ: null }, + { json: "romancing", js: "romancing", typ: null }, + { json: "rumness", js: "rumness", typ: null }, + { json: "somniloquist", js: "somniloquist", typ: null }, + { json: "stressfully", js: "stressfully", typ: null }, + { json: "tactically", js: "tactically", typ: null }, + { json: "tracheophony", js: "tracheophony", typ: null }, + { json: "unappositely", js: "unappositely", typ: null }, + { json: "unclothedly", js: "unclothedly", typ: null }, + { json: "unimplied", js: "unimplied", typ: null }, + { json: "unsyncopated", js: "unsyncopated", typ: null }, + ], false), + "QuebrachineClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: i(0) }, + { json: "catharticalness", js: "catharticalness", typ: 3.14 }, + { json: "disdiapason", js: "disdiapason", typ: "" }, + { json: "homocerc", js: "homocerc", typ: true }, + { json: "nonbookish", js: "nonbookish", typ: null }, + ], false), + "Reimagine": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Hermo", js: "Hermo", typ: u(undefined, null) }, + { json: "adducible", js: "adducible", typ: u(undefined, null) }, + { json: "anabolin", js: "anabolin", typ: u(undefined, null) }, + { json: "brainy", js: "brainy", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "chrysamine", js: "chrysamine", typ: u(undefined, null) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "fluxweed", js: "fluxweed", typ: u(undefined, null) }, + { json: "glaucine", js: "glaucine", typ: u(undefined, null) }, + { json: "grobianism", js: "grobianism", typ: u(undefined, null) }, + { json: "hieroglyphist", js: "hieroglyphist", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "icteroid", js: "icteroid", typ: u(undefined, null) }, + { json: "immortal", js: "immortal", typ: u(undefined, null) }, + { json: "impetulant", js: "impetulant", typ: u(undefined, null) }, + { json: "irrigate", js: "irrigate", typ: u(undefined, null) }, + { json: "myxedema", js: "myxedema", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "onyx", js: "onyx", typ: u(undefined, null) }, + { json: "repasser", js: "repasser", typ: u(undefined, null) }, + { json: "septomarginal", js: "septomarginal", typ: u(undefined, null) }, + { json: "subdie", js: "subdie", typ: u(undefined, null) }, + { json: "tibiometatarsal", js: "tibiometatarsal", typ: u(undefined, null) }, + { json: "waltzlike", js: "waltzlike", typ: u(undefined, null) }, + ], false), + "Ressaut": o([ + { json: "Freesia", js: "Freesia", typ: "" }, + { json: "Genevieve", js: "Genevieve", typ: "" }, + { json: "Mimosaceae", js: "Mimosaceae", typ: "" }, + { json: "Theopaschitism", js: "Theopaschitism", typ: "" }, + { json: "apperceptive", js: "apperceptive", typ: "" }, + { json: "cuttoo", js: "cuttoo", typ: "" }, + { json: "douser", js: "douser", typ: "" }, + { json: "drinkproof", js: "drinkproof", typ: "" }, + { json: "forementioned", js: "forementioned", typ: "" }, + { json: "hyperdiabolical", js: "hyperdiabolical", typ: "" }, + { json: "hypocone", js: "hypocone", typ: "" }, + { json: "irreverentially", js: "irreverentially", typ: "" }, + { json: "jumart", js: "jumart", typ: "" }, + { json: "mollicrush", js: "mollicrush", typ: "" }, + { json: "nedder", js: "nedder", typ: "" }, + { json: "retinasphalt", js: "retinasphalt", typ: "" }, + { json: "sough", js: "sough", typ: "" }, + { json: "steading", js: "steading", typ: "" }, + { json: "undurableness", js: "undurableness", typ: "" }, + { json: "unmingleable", js: "unmingleable", typ: "" }, + ], false), + "RewriteClass": o([ + { json: "Hyades", js: "Hyades", typ: null }, + { json: "Ptenoglossa", js: "Ptenoglossa", typ: null }, + { json: "Whiggification", js: "Whiggification", typ: null }, + { json: "accountancy", js: "accountancy", typ: null }, + { json: "cacotrophic", js: "cacotrophic", typ: null }, + { json: "contest", js: "contest", typ: null }, + { json: "couthily", js: "couthily", typ: null }, + { json: "falculate", js: "falculate", typ: null }, + { json: "foreseize", js: "foreseize", typ: null }, + { json: "lemnad", js: "lemnad", typ: null }, + { json: "monotheistically", js: "monotheistically", typ: null }, + { json: "nonflying", js: "nonflying", typ: null }, + { json: "repatch", js: "repatch", typ: null }, + { json: "rodman", js: "rodman", typ: null }, + { json: "strung", js: "strung", typ: null }, + { json: "titmal", js: "titmal", typ: null }, + { json: "twalpennyworth", js: "twalpennyworth", typ: null }, + { json: "unblamable", js: "unblamable", typ: null }, + { json: "vertical", js: "vertical", typ: null }, + { json: "yardman", js: "yardman", typ: null }, + ], false), + "SantirClass": o([ + { json: "Suessiones", js: "Suessiones", typ: null }, + { json: "admiredly", js: "admiredly", typ: null }, + { json: "demicaponier", js: "demicaponier", typ: null }, + { json: "epitympanic", js: "epitympanic", typ: null }, + { json: "investitor", js: "investitor", typ: null }, + { json: "lupiform", js: "lupiform", typ: null }, + { json: "monoflagellate", js: "monoflagellate", typ: null }, + { json: "paleoethnic", js: "paleoethnic", typ: null }, + { json: "prediscountable", js: "prediscountable", typ: null }, + { json: "rhetoricals", js: "rhetoricals", typ: null }, + { json: "roomth", js: "roomth", typ: null }, + { json: "saccharose", js: "saccharose", typ: null }, + { json: "septonasal", js: "septonasal", typ: null }, + { json: "serpenticide", js: "serpenticide", typ: null }, + { json: "setarious", js: "setarious", typ: null }, + { json: "spaework", js: "spaework", typ: null }, + { json: "stylite", js: "stylite", typ: null }, + { json: "timelily", js: "timelily", typ: null }, + { json: "unprofaned", js: "unprofaned", typ: null }, + { json: "vorticular", js: "vorticular", typ: null }, + ], false), + "SaxtenClass": o([ + { json: "Centaurid", js: "Centaurid", typ: u(undefined, null) }, + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "algarrobilla", js: "algarrobilla", typ: u(undefined, null) }, + { json: "bowgrace", js: "bowgrace", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "flix", js: "flix", typ: u(undefined, null) }, + { json: "germanely", js: "germanely", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "inhume", js: "inhume", typ: u(undefined, null) }, + { json: "lepidote", js: "lepidote", typ: u(undefined, null) }, + { json: "megalochirous", js: "megalochirous", typ: u(undefined, null) }, + { json: "ninepenny", js: "ninepenny", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "nondeist", js: "nondeist", typ: u(undefined, null) }, + { json: "nymphaeaceous", js: "nymphaeaceous", typ: u(undefined, null) }, + { json: "parietofrontal", js: "parietofrontal", typ: u(undefined, null) }, + { json: "sancyite", js: "sancyite", typ: u(undefined, null) }, + { json: "subjectivist", js: "subjectivist", typ: u(undefined, null) }, + { json: "tibiad", js: "tibiad", typ: u(undefined, null) }, + { json: "transonic", js: "transonic", typ: u(undefined, null) }, + { json: "tripetalous", js: "tripetalous", typ: u(undefined, null) }, + { json: "trunchman", js: "trunchman", typ: u(undefined, null) }, + { json: "urger", js: "urger", typ: u(undefined, null) }, + { json: "withdrawnness", js: "withdrawnness", typ: u(undefined, null) }, + ], false), + "Scatty": o([ + { json: "Tabasco", js: "Tabasco", typ: null }, + { json: "aeriferous", js: "aeriferous", typ: null }, + { json: "antical", js: "antical", typ: null }, + { json: "antighostism", js: "antighostism", typ: null }, + { json: "arcanum", js: "arcanum", typ: null }, + { json: "autotrophy", js: "autotrophy", typ: null }, + { json: "baronial", js: "baronial", typ: null }, + { json: "caffeine", js: "caffeine", typ: null }, + { json: "gorgoniacean", js: "gorgoniacean", typ: null }, + { json: "heroical", js: "heroical", typ: null }, + { json: "hydropical", js: "hydropical", typ: null }, + { json: "mechanology", js: "mechanology", typ: null }, + { json: "musicopoetic", js: "musicopoetic", typ: null }, + { json: "officiality", js: "officiality", typ: null }, + { json: "oftentimes", js: "oftentimes", typ: null }, + { json: "ophthalmotonometer", js: "ophthalmotonometer", typ: null }, + { json: "reflectively", js: "reflectively", typ: null }, + { json: "springer", js: "springer", typ: null }, + { json: "teleianthous", js: "teleianthous", typ: null }, + { json: "uncombated", js: "uncombated", typ: null }, + ], false), + "SisteringClass": o([ + { json: "Chianti", js: "Chianti", typ: null }, + { json: "Haplomi", js: "Haplomi", typ: null }, + { json: "Micropterygidae", js: "Micropterygidae", typ: null }, + { json: "amphicarpic", js: "amphicarpic", typ: null }, + { json: "frigorific", js: "frigorific", typ: null }, + { json: "hyperkinesis", js: "hyperkinesis", typ: null }, + { json: "laudable", js: "laudable", typ: null }, + { json: "madwoman", js: "madwoman", typ: null }, + { json: "maimedly", js: "maimedly", typ: null }, + { json: "microrhabdus", js: "microrhabdus", typ: null }, + { json: "nondense", js: "nondense", typ: null }, + { json: "phlebemphraxis", js: "phlebemphraxis", typ: null }, + { json: "redsear", js: "redsear", typ: null }, + { json: "schismatical", js: "schismatical", typ: null }, + { json: "tartryl", js: "tartryl", typ: null }, + { json: "unabhorred", js: "unabhorred", typ: null }, + { json: "undeliberateness", js: "undeliberateness", typ: null }, + { json: "unmixable", js: "unmixable", typ: null }, + { json: "untruckling", js: "untruckling", typ: null }, + { json: "vineal", js: "vineal", typ: null }, + ], false), + "Staghunting": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "calorimetric", js: "calorimetric", typ: u(undefined, i(0)) }, + { json: "canid", js: "canid", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "ditriglyphic", js: "ditriglyphic", typ: u(undefined, i(0)) }, + { json: "floriferousness", js: "floriferousness", typ: u(undefined, i(0)) }, + { json: "gamelike", js: "gamelike", typ: u(undefined, i(0)) }, + { json: "grig", js: "grig", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "interloan", js: "interloan", typ: u(undefined, i(0)) }, + { json: "lithotomy", js: "lithotomy", typ: u(undefined, i(0)) }, + { json: "loric", js: "loric", typ: u(undefined, i(0)) }, + { json: "membranocoriaceous", js: "membranocoriaceous", typ: u(undefined, i(0)) }, + { json: "membranogenic", js: "membranogenic", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "overtrump", js: "overtrump", typ: u(undefined, i(0)) }, + { json: "scotino", js: "scotino", typ: u(undefined, i(0)) }, + { json: "seasonable", js: "seasonable", typ: u(undefined, i(0)) }, + { json: "sephen", js: "sephen", typ: u(undefined, i(0)) }, + { json: "stigmarioid", js: "stigmarioid", typ: u(undefined, i(0)) }, + { json: "tired", js: "tired", typ: u(undefined, i(0)) }, + { json: "trifid", js: "trifid", typ: u(undefined, i(0)) }, + { json: "undefeatedly", js: "undefeatedly", typ: u(undefined, i(0)) }, + { json: "ungirlish", js: "ungirlish", typ: u(undefined, i(0)) }, + ], false), + "StrenuosityClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Onopordon", js: "Onopordon", typ: u(undefined, i(0)) }, + { json: "Sodomite", js: "Sodomite", typ: u(undefined, i(0)) }, + { json: "Yankeeist", js: "Yankeeist", typ: u(undefined, i(0)) }, + { json: "bliss", js: "bliss", typ: u(undefined, i(0)) }, + { json: "buccate", js: "buccate", typ: u(undefined, i(0)) }, + { json: "bulletproof", js: "bulletproof", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "crumblingness", js: "crumblingness", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "engagedly", js: "engagedly", typ: u(undefined, i(0)) }, + { json: "fightable", js: "fightable", typ: u(undefined, i(0)) }, + { json: "hoariness", js: "hoariness", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "hypopodium", js: "hypopodium", typ: u(undefined, i(0)) }, + { json: "luxurist", js: "luxurist", typ: u(undefined, i(0)) }, + { json: "mechanician", js: "mechanician", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "podgily", js: "podgily", typ: u(undefined, i(0)) }, + { json: "reformableness", js: "reformableness", typ: u(undefined, i(0)) }, + { json: "scatterbrains", js: "scatterbrains", typ: u(undefined, i(0)) }, + { json: "seminuria", js: "seminuria", typ: u(undefined, i(0)) }, + { json: "tramp", js: "tramp", typ: u(undefined, i(0)) }, + { json: "undueness", js: "undueness", typ: u(undefined, i(0)) }, + { json: "worthily", js: "worthily", typ: u(undefined, i(0)) }, + ], false), + "TruantcyClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Epeira", js: "Epeira", typ: u(undefined, null) }, + { json: "Eurylaimi", js: "Eurylaimi", typ: u(undefined, null) }, + { json: "Yuman", js: "Yuman", typ: u(undefined, null) }, + { json: "alfiona", js: "alfiona", typ: u(undefined, null) }, + { json: "ascaridiasis", js: "ascaridiasis", typ: u(undefined, null) }, + { json: "bungey", js: "bungey", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "ceroxyle", js: "ceroxyle", typ: u(undefined, null) }, + { json: "chorology", js: "chorology", typ: u(undefined, null) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "enmarble", js: "enmarble", typ: u(undefined, null) }, + { json: "germination", js: "germination", typ: u(undefined, null) }, + { json: "hallelujah", js: "hallelujah", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "lev", js: "lev", typ: u(undefined, null) }, + { json: "mouthing", js: "mouthing", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "philliloo", js: "philliloo", typ: u(undefined, null) }, + { json: "planetal", js: "planetal", typ: u(undefined, null) }, + { json: "poney", js: "poney", typ: u(undefined, null) }, + { json: "punctualist", js: "punctualist", typ: u(undefined, null) }, + { json: "returnlessly", js: "returnlessly", typ: u(undefined, null) }, + { json: "skelder", js: "skelder", typ: u(undefined, null) }, + { json: "windwaywardly", js: "windwaywardly", typ: u(undefined, null) }, + ], false), + "UnimpeachablyClass": o([ + { json: "Bobadil", js: "Bobadil", typ: u(undefined, i(0)) }, + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Quiina", js: "Quiina", typ: u(undefined, i(0)) }, + { json: "Robert", js: "Robert", typ: u(undefined, i(0)) }, + { json: "acerin", js: "acerin", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "chlorophylligenous", js: "chlorophylligenous", typ: u(undefined, i(0)) }, + { json: "conversational", js: "conversational", typ: u(undefined, i(0)) }, + { json: "demiowl", js: "demiowl", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "ectorhinal", js: "ectorhinal", typ: u(undefined, i(0)) }, + { json: "gamblesomeness", js: "gamblesomeness", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "irrorate", js: "irrorate", typ: u(undefined, i(0)) }, + { json: "kindergartening", js: "kindergartening", typ: u(undefined, i(0)) }, + { json: "lateritic", js: "lateritic", typ: u(undefined, i(0)) }, + { json: "mespil", js: "mespil", typ: u(undefined, i(0)) }, + { json: "misconfiguration", js: "misconfiguration", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "planometry", js: "planometry", typ: u(undefined, i(0)) }, + { json: "rot", js: "rot", typ: u(undefined, i(0)) }, + { json: "subcinctorium", js: "subcinctorium", typ: u(undefined, i(0)) }, + { json: "tussocker", js: "tussocker", typ: u(undefined, i(0)) }, + { json: "ultraproud", js: "ultraproud", typ: u(undefined, i(0)) }, + { json: "unsuggestedness", js: "unsuggestedness", typ: u(undefined, i(0)) }, + ], false), + "UnstressedClass": o([ + { json: "Alain", js: "Alain", typ: null }, + { json: "Amphirhina", js: "Amphirhina", typ: null }, + { json: "Lincolnian", js: "Lincolnian", typ: null }, + { json: "Sarcophilus", js: "Sarcophilus", typ: null }, + { json: "antimachinery", js: "antimachinery", typ: null }, + { json: "coldish", js: "coldish", typ: null }, + { json: "crantara", js: "crantara", typ: null }, + { json: "distinguishing", js: "distinguishing", typ: null }, + { json: "elytroposis", js: "elytroposis", typ: null }, + { json: "gentianwort", js: "gentianwort", typ: null }, + { json: "heliosis", js: "heliosis", typ: null }, + { json: "instrumental", js: "instrumental", typ: null }, + { json: "introinflection", js: "introinflection", typ: null }, + { json: "kala", js: "kala", typ: null }, + { json: "metad", js: "metad", typ: null }, + { json: "swingingly", js: "swingingly", typ: null }, + { json: "unconformity", js: "unconformity", typ: null }, + { json: "undecreed", js: "undecreed", typ: null }, + { json: "venerable", js: "venerable", typ: null }, + { json: "vowellessness", js: "vowellessness", typ: null }, + ], false), + "WrothyClass": o([ + { json: "Aeschynanthus", js: "Aeschynanthus", typ: null }, + { json: "Ephesine", js: "Ephesine", typ: null }, + { json: "aquiferous", js: "aquiferous", typ: null }, + { json: "cheapener", js: "cheapener", typ: null }, + { json: "enumeration", js: "enumeration", typ: null }, + { json: "escadrille", js: "escadrille", typ: null }, + { json: "estrous", js: "estrous", typ: null }, + { json: "interestedly", js: "interestedly", typ: null }, + { json: "katakinetomer", js: "katakinetomer", typ: null }, + { json: "mortification", js: "mortification", typ: null }, + { json: "morula", js: "morula", typ: null }, + { json: "orthosymmetrical", js: "orthosymmetrical", typ: null }, + { json: "overbark", js: "overbark", typ: null }, + { json: "politist", js: "politist", typ: null }, + { json: "qualified", js: "qualified", typ: null }, + { json: "sphenomalar", js: "sphenomalar", typ: null }, + { json: "throatful", js: "throatful", typ: null }, + { json: "transhumance", js: "transhumance", typ: null }, + { json: "triandrian", js: "triandrian", typ: null }, + { json: "unbooked", js: "unbooked", typ: null }, + ], false), +}; diff --git a/head/typescript/test/inputs/json/priority/combinations4.json/prefer-types-true--df33e18681f9/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations4.json/prefer-types-true--df33e18681f9/TopLevel.ts new file mode 100644 index 0000000..7232170 --- /dev/null +++ b/head/typescript/test/inputs/json/priority/combinations4.json/prefer-types-true--df33e18681f9/TopLevel.ts @@ -0,0 +1,1140 @@ +// To parse this data: +// +// import { Convert, TopLevel } from "./TopLevel"; +// +// const topLevel = Convert.toTopLevel(json); +// +// These functions will throw an error if the JSON doesn't +// match the expected interface, even if the JSON is valid. + +export type TopLevel = { + protrusive: Protrusive[]; + pulpitism: PulpitismElement[]; + pyodermia: PyodermiaElement[]; + quebrachine: QuebrachineElement[]; + querier: Querier[]; + rebarbative: Rebarbative[]; + reimagine: Reimagine[]; + ressaut: Ressaut; + retrocervical: Retrocervical[]; + revert: Revert[]; + rewrite: RewriteElement[]; + saccoderm: Saccoderm[]; + santir: SantirElement[]; + saprophilous: Saprophilous[]; + saxten: SaxtenElement[]; + scatty: (Scatty | null)[]; + scoffer: Scoffer[]; + scrampum: Scrampum[]; + semantic: number; + serpentinic: Serpentinic[]; + shadowable: Shadowable[]; + sistering: SisteringElement[]; + staghunting: Staghunting[]; + stagmometer: Stagmometer[]; + stimulability: Stimulability[]; + strangleable: Strangleable[]; + strenuosity: StrenuosityElement[]; + tabaxir: Tabaxir[]; + talpiform: Talpiform[]; + thwack: Thwack[]; + to: (number | null)[]; + tortricine: Tortricine[]; + truantcy: TruantcyElement[]; + turgesce: string[]; + unbeginning: Unbeginning[]; + underdunged: number[]; + undesirability: Undesirability[]; + unerasing: Unerasing[]; + unguentarium: Unguentarium[]; + unimpeachably: UnimpeachablyElement[]; + unmortgaged: Unmortgaged[]; + unobstructed: Unobstructed[]; + unreceptivity: Unreceptivity[]; + unsatisfactoriness: Unsatisfactoriness[]; + unsecurity: number[]; + unstressed: UnstressedElement[]; + untasked: Untasked[]; + unvarying: Unvarying[]; + vehemently: Vehemently[]; + warriorship: { [key: string]: boolean }; + whitepot: Whitepot[]; + wrothy: WrothyElement[]; +} + +export type Protrusive = (number | null)[] | number; + +export type PulpitismElement = number[] | PulpitismClass | number; + +export type PulpitismClass = { + abnet: null; + buckhorn: null; + calciform: null; + chelophore: null; + cogitation: null; + decreeable: null; + despicable: null; + isodiazo: null; + jadedly: null; + leptochlorite: null; + nursling: null; + palamedean: null; + photoheliograph: null; + pipewood: null; + roberd: null; + statable: null; + superassume: null; + syllabe: null; + toughhead: null; + underburn: null; +} + +export type PyodermiaElement = PyodermiaClass | number; + +export type PyodermiaClass = { + Gyppo: null; + aphoristically: null; + apophyllous: null; + cognize: null; + dermonosology: null; + ither: null; + juglandaceous: null; + litho: null; + macropterous: null; + photographer: null; + romancing: null; + rumness: null; + somniloquist: null; + stressfully: null; + tactically: null; + tracheophony: null; + unappositely: null; + unclothedly: null; + unimplied: null; + unsyncopated: null; +} + +export type QuebrachineElement = boolean | QuebrachineClass | null; + +export type QuebrachineClass = { + Chirotherium: number; + catharticalness: number; + disdiapason: string; + homocerc: boolean; + nonbookish: null; +} + +export type Querier = boolean | { [key: string]: number }; + +export type Rebarbative = number[] | boolean | number; + +export type Reimagine = { + Chirotherium?: number; + Hermo?: null; + adducible?: null; + anabolin?: null; + brainy?: null; + catharticalness?: number; + chrysamine?: null; + disdiapason?: string; + fluxweed?: null; + glaucine?: null; + grobianism?: null; + hieroglyphist?: null; + homocerc?: boolean; + icteroid?: null; + immortal?: null; + impetulant?: null; + irrigate?: null; + myxedema?: null; + nonbookish?: null; + onyx?: null; + repasser?: null; + septomarginal?: null; + subdie?: null; + tibiometatarsal?: null; + waltzlike?: null; +} + +export type Ressaut = { + Freesia: string; + Genevieve: string; + Mimosaceae: string; + Theopaschitism: string; + apperceptive: string; + cuttoo: string; + douser: string; + drinkproof: string; + forementioned: string; + hyperdiabolical: string; + hypocone: string; + irreverentially: string; + jumart: string; + mollicrush: string; + nedder: string; + retinasphalt: string; + sough: string; + steading: string; + undurableness: string; + unmingleable: string; +} + +export type Retrocervical = (number | null)[] | number; + +export type Revert = boolean | string; + +export type RewriteElement = null[] | RewriteClass | number; + +export type RewriteClass = { + Hyades: null; + Ptenoglossa: null; + Whiggification: null; + accountancy: null; + cacotrophic: null; + contest: null; + couthily: null; + falculate: null; + foreseize: null; + lemnad: null; + monotheistically: null; + nonflying: null; + repatch: null; + rodman: null; + strung: null; + titmal: null; + twalpennyworth: null; + unblamable: null; + vertical: null; + yardman: null; +} + +export type Saccoderm = number[] | null | string; + +export type SantirElement = SantirClass | number; + +export type SantirClass = { + Suessiones: null; + admiredly: null; + demicaponier: null; + epitympanic: null; + investitor: null; + lupiform: null; + monoflagellate: null; + paleoethnic: null; + prediscountable: null; + rhetoricals: null; + roomth: null; + saccharose: null; + septonasal: null; + serpenticide: null; + setarious: null; + spaework: null; + stylite: null; + timelily: null; + unprofaned: null; + vorticular: null; +} + +export type Saprophilous = { [key: string]: number } | null | string; + +export type SaxtenElement = SaxtenClass | string; + +export type SaxtenClass = { + Centaurid?: null; + Chirotherium?: number; + algarrobilla?: null; + bowgrace?: null; + catharticalness?: number; + disdiapason?: string; + flix?: null; + germanely?: null; + homocerc?: boolean; + inhume?: null; + lepidote?: null; + megalochirous?: null; + ninepenny?: null; + nonbookish?: null; + nondeist?: null; + nymphaeaceous?: null; + parietofrontal?: null; + sancyite?: null; + subjectivist?: null; + tibiad?: null; + transonic?: null; + tripetalous?: null; + trunchman?: null; + urger?: null; + withdrawnness?: null; +} + +export type Scatty = { + Tabasco: null; + aeriferous: null; + antical: null; + antighostism: null; + arcanum: null; + autotrophy: null; + baronial: null; + caffeine: null; + gorgoniacean: null; + heroical: null; + hydropical: null; + mechanology: null; + musicopoetic: null; + officiality: null; + oftentimes: null; + ophthalmotonometer: null; + reflectively: null; + springer: null; + teleianthous: null; + uncombated: null; +} + +export type Scoffer = null[] | { [key: string]: number } | null; + +export type Scrampum = number[] | boolean | null; + +export type Serpentinic = number[] | number; + +export type Shadowable = (number | null)[] | boolean; + +export type SisteringElement = null[] | SisteringClass | number; + +export type SisteringClass = { + Chianti: null; + Haplomi: null; + Micropterygidae: null; + amphicarpic: null; + frigorific: null; + hyperkinesis: null; + laudable: null; + madwoman: null; + maimedly: null; + microrhabdus: null; + nondense: null; + phlebemphraxis: null; + redsear: null; + schismatical: null; + tartryl: null; + unabhorred: null; + undeliberateness: null; + unmixable: null; + untruckling: null; + vineal: null; +} + +export type Staghunting = { + Chirotherium?: number; + calorimetric?: number; + canid?: number; + catharticalness?: number; + disdiapason?: string; + ditriglyphic?: number; + floriferousness?: number; + gamelike?: number; + grig?: number; + homocerc?: boolean; + interloan?: number; + lithotomy?: number; + loric?: number; + membranocoriaceous?: number; + membranogenic?: number; + nonbookish?: null; + overtrump?: number; + scotino?: number; + seasonable?: number; + sephen?: number; + stigmarioid?: number; + tired?: number; + trifid?: number; + undefeatedly?: number; + ungirlish?: number; +} + +export type Stagmometer = (number | null)[] | string; + +export type Stimulability = boolean | number | { [key: string]: number }; + +export type Strangleable = null[] | number; + +export type StrenuosityElement = null[] | StrenuosityClass; + +export type StrenuosityClass = { + Chirotherium?: number; + Onopordon?: number; + Sodomite?: number; + Yankeeist?: number; + bliss?: number; + buccate?: number; + bulletproof?: number; + catharticalness?: number; + crumblingness?: number; + disdiapason?: string; + engagedly?: number; + fightable?: number; + hoariness?: number; + homocerc?: boolean; + hypopodium?: number; + luxurist?: number; + mechanician?: number; + nonbookish?: null; + podgily?: number; + reformableness?: number; + scatterbrains?: number; + seminuria?: number; + tramp?: number; + undueness?: number; + worthily?: number; +} + +export type Tabaxir = boolean | number; + +export type Talpiform = QuebrachineClass | number | null; + +export type Thwack = boolean | QuebrachineClass | number; + +export type Tortricine = (number | null)[] | QuebrachineClass; + +export type TruantcyElement = boolean | TruantcyClass; + +export type TruantcyClass = { + Chirotherium?: number; + Epeira?: null; + Eurylaimi?: null; + Yuman?: null; + alfiona?: null; + ascaridiasis?: null; + bungey?: null; + catharticalness?: number; + ceroxyle?: null; + chorology?: null; + disdiapason?: string; + enmarble?: null; + germination?: null; + hallelujah?: null; + homocerc?: boolean; + lev?: null; + mouthing?: null; + nonbookish?: null; + philliloo?: null; + planetal?: null; + poney?: null; + punctualist?: null; + returnlessly?: null; + skelder?: null; + windwaywardly?: null; +} + +export type Unbeginning = null[] | { [key: string]: number } | string; + +export type Undesirability = number[] | { [key: string]: number } | string; + +export type Unerasing = null[] | number | { [key: string]: number }; + +export type Unguentarium = null[] | number | null; + +export type UnimpeachablyElement = boolean | UnimpeachablyClass; + +export type UnimpeachablyClass = { + Bobadil?: number; + Chirotherium?: number; + Quiina?: number; + Robert?: number; + acerin?: number; + catharticalness?: number; + chlorophylligenous?: number; + conversational?: number; + demiowl?: number; + disdiapason?: string; + ectorhinal?: number; + gamblesomeness?: number; + homocerc?: boolean; + irrorate?: number; + kindergartening?: number; + lateritic?: number; + mespil?: number; + misconfiguration?: number; + nonbookish?: null; + planometry?: number; + rot?: number; + subcinctorium?: number; + tussocker?: number; + ultraproud?: number; + unsuggestedness?: number; +} + +export type Unmortgaged = number | { [key: string]: number } | null; + +export type Unobstructed = QuebrachineClass | number | null; + +export type Unreceptivity = null[] | number | string; + +export type Unsatisfactoriness = number[] | boolean | number; + +export type UnstressedElement = boolean | UnstressedClass | string; + +export type UnstressedClass = { + Alain: null; + Amphirhina: null; + Lincolnian: null; + Sarcophilus: null; + antimachinery: null; + coldish: null; + crantara: null; + distinguishing: null; + elytroposis: null; + gentianwort: null; + heliosis: null; + instrumental: null; + introinflection: null; + kala: null; + metad: null; + swingingly: null; + unconformity: null; + undecreed: null; + venerable: null; + vowellessness: null; +} + +export type Untasked = null[] | number | { [key: string]: number }; + +export type Unvarying = boolean | number | { [key: string]: number }; + +export type Vehemently = null[] | boolean | null; + +export type Whitepot = QuebrachineClass | number; + +export type WrothyElement = null[] | WrothyClass; + +export type WrothyClass = { + Aeschynanthus: null; + Ephesine: null; + aquiferous: null; + cheapener: null; + enumeration: null; + escadrille: null; + estrous: null; + interestedly: null; + katakinetomer: null; + mortification: null; + morula: null; + orthosymmetrical: null; + overbark: null; + politist: null; + qualified: null; + sphenomalar: null; + throatful: null; + transhumance: null; + triandrian: null; + unbooked: null; +} + +// Converts JSON strings to/from your types +// and asserts the results of JSON.parse at runtime +export class Convert { + public static toTopLevel(json: string): TopLevel { + return cast(JSON.parse(json), r("TopLevel")); + } + + public static topLevelToJson(value: TopLevel): string { + return JSON.stringify(uncast(value, r("TopLevel")), null, 2); + } +} + +function invalidValue(typ: any, val: any, key: any, parent: any = ''): never { + const prettyTyp = prettyTypeName(typ); + const parentText = parent ? ` on ${parent}` : ''; + const keyText = key ? ` for key "${key}"` : ''; + throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`); +} + +function prettyTypeName(typ: any): string { + if (Array.isArray(typ)) { + if (typ.length === 2 && typ[0] === undefined) { + return `an optional ${prettyTypeName(typ[1])}`; + } else { + return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`; + } + } else if (typeof typ === "object" && typ.literal !== undefined) { + return typ.literal; + } else { + return typeof typ; + } +} + +function jsonToJSProps(typ: any): any { + if (typ.jsonToJS === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ }); + typ.jsonToJS = map; + } + return typ.jsonToJS; +} + +function jsToJSONProps(typ: any): any { + if (typ.jsToJSON === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ }); + typ.jsToJSON = map; + } + return typ.jsToJSON; +} + +function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any { + function transformPrimitive(typ: string, val: any): any { + if (typeof typ === typeof val) return val; + return invalidValue(typ, val, key, parent); + } + + function transformUnion(typs: any[], val: any): any { + // val must validate against one typ in typs + const l = typs.length; + for (let i = 0; i < l; i++) { + const typ = typs[i]; + try { + return transform(val, typ, getProps); + } catch (_) {} + } + return invalidValue(typs, val, key, parent); + } + + function transformEnum(cases: string[], val: any): any { + if (cases.indexOf(val) !== -1) return val; + return invalidValue(cases.map(a => { return l(a); }), val, key, parent); + } + + function transformArray(typ: any, val: any): any { + // val must be an array with no invalid elements + if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent); + + return val.map(el => transform(el, typ, getProps)); + } + + function transformDate(val: any): any { + if (val === null) { + return null; + } + const d = new Date(val); + if (isNaN(d.valueOf())) { + return invalidValue(l("Date"), val, key, parent); + } + return d; + } + + function transformObject(props: { [k: string]: any }, additional: any, val: any): any { + if (val === null || typeof val !== "object" || Array.isArray(val)) { + return invalidValue(l(ref || "object"), val, key, parent); + } + const result: any = {}; + Object.getOwnPropertyNames(props).forEach(key => { + const prop = props[key]; + const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined; + result[prop.key] = transform(v, prop.typ, getProps, key, ref); + }); + Object.getOwnPropertyNames(val).forEach(key => { + if (!Object.prototype.hasOwnProperty.call(props, key)) { + result[key] = transform(val[key], additional, getProps, key, ref); + } + }); + return result; + } + + if (typ === "any") return val; + if (typ === null) { + if (val === null) return val; + return invalidValue(typ, val, key, parent); + } + if (typ === false) return invalidValue(typ, val, key, parent); + let ref: any = undefined; + while (typeof typ === "object" && typ.ref !== undefined) { + ref = typ.ref; + typ = typeMap[typ.ref]; + } + if (Array.isArray(typ)) return transformEnum(typ, val); + if (typeof typ === "object") { + return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) + : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) + : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val) + : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val) + : invalidValue(typ, val, key, parent); + } + // Numbers can be parsed by Date but shouldn't be. + if (typ === Date && typeof val !== "number") return transformDate(val); + return transformPrimitive(typ, val); +} + +function cast(val: any, typ: any): T { + return transform(val, typ, jsonToJSProps); +} + +function uncast(val: T, typ: any): any { + return transform(val, typ, jsToJSONProps); +} + +function l(typ: any) { + return { literal: typ }; +} + +function a(typ: any) { + return { arrayItems: typ }; +} + +function i(typ: any) { + return { integer: typ }; +} + +function p(pattern: any) { + return { pattern }; +} + +function s(typ: any, min: any, max: any) { + return { string: typ, min, max }; +} + +function n(typ: any, min: any, max: any) { + return { number: typ, min, max }; +} + +function u(...typs: any[]) { + return { unionMembers: typs }; +} + +function o(props: any[], additional: any) { + return { props, additional }; +} + +function m(additional: any) { + const props: any[] = []; + return { props, additional }; +} + +function r(name: string) { + return { ref: name }; +} + +const typeMap: any = { + "TopLevel": o([ + { json: "protrusive", js: "protrusive", typ: a(u(a(u(i(0), null)), 3.14)) }, + { json: "pulpitism", js: "pulpitism", typ: a(u(a(i(0)), r("PulpitismClass"), 3.14)) }, + { json: "pyodermia", js: "pyodermia", typ: a(u(r("PyodermiaClass"), i(0))) }, + { json: "quebrachine", js: "quebrachine", typ: a(u(true, r("QuebrachineClass"), null)) }, + { json: "querier", js: "querier", typ: a(u(true, m(i(0)))) }, + { json: "rebarbative", js: "rebarbative", typ: a(u(a(i(0)), true, 3.14)) }, + { json: "reimagine", js: "reimagine", typ: a(r("Reimagine")) }, + { json: "ressaut", js: "ressaut", typ: r("Ressaut") }, + { json: "retrocervical", js: "retrocervical", typ: a(u(a(u(i(0), null)), i(0))) }, + { json: "revert", js: "revert", typ: a(u(true, "")) }, + { json: "rewrite", js: "rewrite", typ: a(u(a(null), r("RewriteClass"), 3.14)) }, + { json: "saccoderm", js: "saccoderm", typ: a(u(a(i(0)), null, "")) }, + { json: "santir", js: "santir", typ: a(u(r("SantirClass"), 3.14)) }, + { json: "saprophilous", js: "saprophilous", typ: a(u(m(i(0)), null, "")) }, + { json: "saxten", js: "saxten", typ: a(u(r("SaxtenClass"), "")) }, + { json: "scatty", js: "scatty", typ: a(u(r("Scatty"), null)) }, + { json: "scoffer", js: "scoffer", typ: a(u(a(null), m(i(0)), null)) }, + { json: "scrampum", js: "scrampum", typ: a(u(a(i(0)), true, null)) }, + { json: "semantic", js: "semantic", typ: 3.14 }, + { json: "serpentinic", js: "serpentinic", typ: a(u(a(i(0)), 3.14)) }, + { json: "shadowable", js: "shadowable", typ: a(u(a(u(i(0), null)), true)) }, + { json: "sistering", js: "sistering", typ: a(u(a(null), r("SisteringClass"), i(0))) }, + { json: "staghunting", js: "staghunting", typ: a(r("Staghunting")) }, + { json: "stagmometer", js: "stagmometer", typ: a(u(a(u(i(0), null)), "")) }, + { json: "stimulability", js: "stimulability", typ: a(u(true, i(0), m(i(0)))) }, + { json: "strangleable", js: "strangleable", typ: a(u(a(null), 3.14)) }, + { json: "strenuosity", js: "strenuosity", typ: a(u(a(null), r("StrenuosityClass"))) }, + { json: "tabaxir", js: "tabaxir", typ: a(u(true, 3.14)) }, + { json: "talpiform", js: "talpiform", typ: a(u(r("QuebrachineClass"), 3.14, null)) }, + { json: "thwack", js: "thwack", typ: a(u(true, r("QuebrachineClass"), 3.14)) }, + { json: "to", js: "to", typ: a(u(3.14, null)) }, + { json: "tortricine", js: "tortricine", typ: a(u(a(u(i(0), null)), r("QuebrachineClass"))) }, + { json: "truantcy", js: "truantcy", typ: a(u(true, r("TruantcyClass"))) }, + { json: "turgesce", js: "turgesce", typ: a("") }, + { json: "unbeginning", js: "unbeginning", typ: a(u(a(null), m(i(0)), "")) }, + { json: "underdunged", js: "underdunged", typ: a(3.14) }, + { json: "undesirability", js: "undesirability", typ: a(u(a(i(0)), m(i(0)), "")) }, + { json: "unerasing", js: "unerasing", typ: a(u(a(null), i(0), m(i(0)))) }, + { json: "unguentarium", js: "unguentarium", typ: a(u(a(null), i(0), null)) }, + { json: "unimpeachably", js: "unimpeachably", typ: a(u(true, r("UnimpeachablyClass"))) }, + { json: "unmortgaged", js: "unmortgaged", typ: a(u(3.14, m(i(0)), null)) }, + { json: "unobstructed", js: "unobstructed", typ: a(u(r("QuebrachineClass"), i(0), null)) }, + { json: "unreceptivity", js: "unreceptivity", typ: a(u(a(null), i(0), "")) }, + { json: "unsatisfactoriness", js: "unsatisfactoriness", typ: a(u(a(i(0)), true, i(0))) }, + { json: "unsecurity", js: "unsecurity", typ: a(i(0)) }, + { json: "unstressed", js: "unstressed", typ: a(u(true, r("UnstressedClass"), "")) }, + { json: "untasked", js: "untasked", typ: a(u(a(null), 3.14, m(i(0)))) }, + { json: "unvarying", js: "unvarying", typ: a(u(true, 3.14, m(i(0)))) }, + { json: "vehemently", js: "vehemently", typ: a(u(a(null), true, null)) }, + { json: "warriorship", js: "warriorship", typ: m(true) }, + { json: "whitepot", js: "whitepot", typ: a(u(r("QuebrachineClass"), 3.14)) }, + { json: "wrothy", js: "wrothy", typ: a(u(a(null), r("WrothyClass"))) }, + ], false), + "PulpitismClass": o([ + { json: "abnet", js: "abnet", typ: null }, + { json: "buckhorn", js: "buckhorn", typ: null }, + { json: "calciform", js: "calciform", typ: null }, + { json: "chelophore", js: "chelophore", typ: null }, + { json: "cogitation", js: "cogitation", typ: null }, + { json: "decreeable", js: "decreeable", typ: null }, + { json: "despicable", js: "despicable", typ: null }, + { json: "isodiazo", js: "isodiazo", typ: null }, + { json: "jadedly", js: "jadedly", typ: null }, + { json: "leptochlorite", js: "leptochlorite", typ: null }, + { json: "nursling", js: "nursling", typ: null }, + { json: "palamedean", js: "palamedean", typ: null }, + { json: "photoheliograph", js: "photoheliograph", typ: null }, + { json: "pipewood", js: "pipewood", typ: null }, + { json: "roberd", js: "roberd", typ: null }, + { json: "statable", js: "statable", typ: null }, + { json: "superassume", js: "superassume", typ: null }, + { json: "syllabe", js: "syllabe", typ: null }, + { json: "toughhead", js: "toughhead", typ: null }, + { json: "underburn", js: "underburn", typ: null }, + ], false), + "PyodermiaClass": o([ + { json: "Gyppo", js: "Gyppo", typ: null }, + { json: "aphoristically", js: "aphoristically", typ: null }, + { json: "apophyllous", js: "apophyllous", typ: null }, + { json: "cognize", js: "cognize", typ: null }, + { json: "dermonosology", js: "dermonosology", typ: null }, + { json: "ither", js: "ither", typ: null }, + { json: "juglandaceous", js: "juglandaceous", typ: null }, + { json: "litho", js: "litho", typ: null }, + { json: "macropterous", js: "macropterous", typ: null }, + { json: "photographer", js: "photographer", typ: null }, + { json: "romancing", js: "romancing", typ: null }, + { json: "rumness", js: "rumness", typ: null }, + { json: "somniloquist", js: "somniloquist", typ: null }, + { json: "stressfully", js: "stressfully", typ: null }, + { json: "tactically", js: "tactically", typ: null }, + { json: "tracheophony", js: "tracheophony", typ: null }, + { json: "unappositely", js: "unappositely", typ: null }, + { json: "unclothedly", js: "unclothedly", typ: null }, + { json: "unimplied", js: "unimplied", typ: null }, + { json: "unsyncopated", js: "unsyncopated", typ: null }, + ], false), + "QuebrachineClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: i(0) }, + { json: "catharticalness", js: "catharticalness", typ: 3.14 }, + { json: "disdiapason", js: "disdiapason", typ: "" }, + { json: "homocerc", js: "homocerc", typ: true }, + { json: "nonbookish", js: "nonbookish", typ: null }, + ], false), + "Reimagine": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Hermo", js: "Hermo", typ: u(undefined, null) }, + { json: "adducible", js: "adducible", typ: u(undefined, null) }, + { json: "anabolin", js: "anabolin", typ: u(undefined, null) }, + { json: "brainy", js: "brainy", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "chrysamine", js: "chrysamine", typ: u(undefined, null) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "fluxweed", js: "fluxweed", typ: u(undefined, null) }, + { json: "glaucine", js: "glaucine", typ: u(undefined, null) }, + { json: "grobianism", js: "grobianism", typ: u(undefined, null) }, + { json: "hieroglyphist", js: "hieroglyphist", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "icteroid", js: "icteroid", typ: u(undefined, null) }, + { json: "immortal", js: "immortal", typ: u(undefined, null) }, + { json: "impetulant", js: "impetulant", typ: u(undefined, null) }, + { json: "irrigate", js: "irrigate", typ: u(undefined, null) }, + { json: "myxedema", js: "myxedema", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "onyx", js: "onyx", typ: u(undefined, null) }, + { json: "repasser", js: "repasser", typ: u(undefined, null) }, + { json: "septomarginal", js: "septomarginal", typ: u(undefined, null) }, + { json: "subdie", js: "subdie", typ: u(undefined, null) }, + { json: "tibiometatarsal", js: "tibiometatarsal", typ: u(undefined, null) }, + { json: "waltzlike", js: "waltzlike", typ: u(undefined, null) }, + ], false), + "Ressaut": o([ + { json: "Freesia", js: "Freesia", typ: "" }, + { json: "Genevieve", js: "Genevieve", typ: "" }, + { json: "Mimosaceae", js: "Mimosaceae", typ: "" }, + { json: "Theopaschitism", js: "Theopaschitism", typ: "" }, + { json: "apperceptive", js: "apperceptive", typ: "" }, + { json: "cuttoo", js: "cuttoo", typ: "" }, + { json: "douser", js: "douser", typ: "" }, + { json: "drinkproof", js: "drinkproof", typ: "" }, + { json: "forementioned", js: "forementioned", typ: "" }, + { json: "hyperdiabolical", js: "hyperdiabolical", typ: "" }, + { json: "hypocone", js: "hypocone", typ: "" }, + { json: "irreverentially", js: "irreverentially", typ: "" }, + { json: "jumart", js: "jumart", typ: "" }, + { json: "mollicrush", js: "mollicrush", typ: "" }, + { json: "nedder", js: "nedder", typ: "" }, + { json: "retinasphalt", js: "retinasphalt", typ: "" }, + { json: "sough", js: "sough", typ: "" }, + { json: "steading", js: "steading", typ: "" }, + { json: "undurableness", js: "undurableness", typ: "" }, + { json: "unmingleable", js: "unmingleable", typ: "" }, + ], false), + "RewriteClass": o([ + { json: "Hyades", js: "Hyades", typ: null }, + { json: "Ptenoglossa", js: "Ptenoglossa", typ: null }, + { json: "Whiggification", js: "Whiggification", typ: null }, + { json: "accountancy", js: "accountancy", typ: null }, + { json: "cacotrophic", js: "cacotrophic", typ: null }, + { json: "contest", js: "contest", typ: null }, + { json: "couthily", js: "couthily", typ: null }, + { json: "falculate", js: "falculate", typ: null }, + { json: "foreseize", js: "foreseize", typ: null }, + { json: "lemnad", js: "lemnad", typ: null }, + { json: "monotheistically", js: "monotheistically", typ: null }, + { json: "nonflying", js: "nonflying", typ: null }, + { json: "repatch", js: "repatch", typ: null }, + { json: "rodman", js: "rodman", typ: null }, + { json: "strung", js: "strung", typ: null }, + { json: "titmal", js: "titmal", typ: null }, + { json: "twalpennyworth", js: "twalpennyworth", typ: null }, + { json: "unblamable", js: "unblamable", typ: null }, + { json: "vertical", js: "vertical", typ: null }, + { json: "yardman", js: "yardman", typ: null }, + ], false), + "SantirClass": o([ + { json: "Suessiones", js: "Suessiones", typ: null }, + { json: "admiredly", js: "admiredly", typ: null }, + { json: "demicaponier", js: "demicaponier", typ: null }, + { json: "epitympanic", js: "epitympanic", typ: null }, + { json: "investitor", js: "investitor", typ: null }, + { json: "lupiform", js: "lupiform", typ: null }, + { json: "monoflagellate", js: "monoflagellate", typ: null }, + { json: "paleoethnic", js: "paleoethnic", typ: null }, + { json: "prediscountable", js: "prediscountable", typ: null }, + { json: "rhetoricals", js: "rhetoricals", typ: null }, + { json: "roomth", js: "roomth", typ: null }, + { json: "saccharose", js: "saccharose", typ: null }, + { json: "septonasal", js: "septonasal", typ: null }, + { json: "serpenticide", js: "serpenticide", typ: null }, + { json: "setarious", js: "setarious", typ: null }, + { json: "spaework", js: "spaework", typ: null }, + { json: "stylite", js: "stylite", typ: null }, + { json: "timelily", js: "timelily", typ: null }, + { json: "unprofaned", js: "unprofaned", typ: null }, + { json: "vorticular", js: "vorticular", typ: null }, + ], false), + "SaxtenClass": o([ + { json: "Centaurid", js: "Centaurid", typ: u(undefined, null) }, + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "algarrobilla", js: "algarrobilla", typ: u(undefined, null) }, + { json: "bowgrace", js: "bowgrace", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "flix", js: "flix", typ: u(undefined, null) }, + { json: "germanely", js: "germanely", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "inhume", js: "inhume", typ: u(undefined, null) }, + { json: "lepidote", js: "lepidote", typ: u(undefined, null) }, + { json: "megalochirous", js: "megalochirous", typ: u(undefined, null) }, + { json: "ninepenny", js: "ninepenny", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "nondeist", js: "nondeist", typ: u(undefined, null) }, + { json: "nymphaeaceous", js: "nymphaeaceous", typ: u(undefined, null) }, + { json: "parietofrontal", js: "parietofrontal", typ: u(undefined, null) }, + { json: "sancyite", js: "sancyite", typ: u(undefined, null) }, + { json: "subjectivist", js: "subjectivist", typ: u(undefined, null) }, + { json: "tibiad", js: "tibiad", typ: u(undefined, null) }, + { json: "transonic", js: "transonic", typ: u(undefined, null) }, + { json: "tripetalous", js: "tripetalous", typ: u(undefined, null) }, + { json: "trunchman", js: "trunchman", typ: u(undefined, null) }, + { json: "urger", js: "urger", typ: u(undefined, null) }, + { json: "withdrawnness", js: "withdrawnness", typ: u(undefined, null) }, + ], false), + "Scatty": o([ + { json: "Tabasco", js: "Tabasco", typ: null }, + { json: "aeriferous", js: "aeriferous", typ: null }, + { json: "antical", js: "antical", typ: null }, + { json: "antighostism", js: "antighostism", typ: null }, + { json: "arcanum", js: "arcanum", typ: null }, + { json: "autotrophy", js: "autotrophy", typ: null }, + { json: "baronial", js: "baronial", typ: null }, + { json: "caffeine", js: "caffeine", typ: null }, + { json: "gorgoniacean", js: "gorgoniacean", typ: null }, + { json: "heroical", js: "heroical", typ: null }, + { json: "hydropical", js: "hydropical", typ: null }, + { json: "mechanology", js: "mechanology", typ: null }, + { json: "musicopoetic", js: "musicopoetic", typ: null }, + { json: "officiality", js: "officiality", typ: null }, + { json: "oftentimes", js: "oftentimes", typ: null }, + { json: "ophthalmotonometer", js: "ophthalmotonometer", typ: null }, + { json: "reflectively", js: "reflectively", typ: null }, + { json: "springer", js: "springer", typ: null }, + { json: "teleianthous", js: "teleianthous", typ: null }, + { json: "uncombated", js: "uncombated", typ: null }, + ], false), + "SisteringClass": o([ + { json: "Chianti", js: "Chianti", typ: null }, + { json: "Haplomi", js: "Haplomi", typ: null }, + { json: "Micropterygidae", js: "Micropterygidae", typ: null }, + { json: "amphicarpic", js: "amphicarpic", typ: null }, + { json: "frigorific", js: "frigorific", typ: null }, + { json: "hyperkinesis", js: "hyperkinesis", typ: null }, + { json: "laudable", js: "laudable", typ: null }, + { json: "madwoman", js: "madwoman", typ: null }, + { json: "maimedly", js: "maimedly", typ: null }, + { json: "microrhabdus", js: "microrhabdus", typ: null }, + { json: "nondense", js: "nondense", typ: null }, + { json: "phlebemphraxis", js: "phlebemphraxis", typ: null }, + { json: "redsear", js: "redsear", typ: null }, + { json: "schismatical", js: "schismatical", typ: null }, + { json: "tartryl", js: "tartryl", typ: null }, + { json: "unabhorred", js: "unabhorred", typ: null }, + { json: "undeliberateness", js: "undeliberateness", typ: null }, + { json: "unmixable", js: "unmixable", typ: null }, + { json: "untruckling", js: "untruckling", typ: null }, + { json: "vineal", js: "vineal", typ: null }, + ], false), + "Staghunting": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "calorimetric", js: "calorimetric", typ: u(undefined, i(0)) }, + { json: "canid", js: "canid", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "ditriglyphic", js: "ditriglyphic", typ: u(undefined, i(0)) }, + { json: "floriferousness", js: "floriferousness", typ: u(undefined, i(0)) }, + { json: "gamelike", js: "gamelike", typ: u(undefined, i(0)) }, + { json: "grig", js: "grig", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "interloan", js: "interloan", typ: u(undefined, i(0)) }, + { json: "lithotomy", js: "lithotomy", typ: u(undefined, i(0)) }, + { json: "loric", js: "loric", typ: u(undefined, i(0)) }, + { json: "membranocoriaceous", js: "membranocoriaceous", typ: u(undefined, i(0)) }, + { json: "membranogenic", js: "membranogenic", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "overtrump", js: "overtrump", typ: u(undefined, i(0)) }, + { json: "scotino", js: "scotino", typ: u(undefined, i(0)) }, + { json: "seasonable", js: "seasonable", typ: u(undefined, i(0)) }, + { json: "sephen", js: "sephen", typ: u(undefined, i(0)) }, + { json: "stigmarioid", js: "stigmarioid", typ: u(undefined, i(0)) }, + { json: "tired", js: "tired", typ: u(undefined, i(0)) }, + { json: "trifid", js: "trifid", typ: u(undefined, i(0)) }, + { json: "undefeatedly", js: "undefeatedly", typ: u(undefined, i(0)) }, + { json: "ungirlish", js: "ungirlish", typ: u(undefined, i(0)) }, + ], false), + "StrenuosityClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Onopordon", js: "Onopordon", typ: u(undefined, i(0)) }, + { json: "Sodomite", js: "Sodomite", typ: u(undefined, i(0)) }, + { json: "Yankeeist", js: "Yankeeist", typ: u(undefined, i(0)) }, + { json: "bliss", js: "bliss", typ: u(undefined, i(0)) }, + { json: "buccate", js: "buccate", typ: u(undefined, i(0)) }, + { json: "bulletproof", js: "bulletproof", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "crumblingness", js: "crumblingness", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "engagedly", js: "engagedly", typ: u(undefined, i(0)) }, + { json: "fightable", js: "fightable", typ: u(undefined, i(0)) }, + { json: "hoariness", js: "hoariness", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "hypopodium", js: "hypopodium", typ: u(undefined, i(0)) }, + { json: "luxurist", js: "luxurist", typ: u(undefined, i(0)) }, + { json: "mechanician", js: "mechanician", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "podgily", js: "podgily", typ: u(undefined, i(0)) }, + { json: "reformableness", js: "reformableness", typ: u(undefined, i(0)) }, + { json: "scatterbrains", js: "scatterbrains", typ: u(undefined, i(0)) }, + { json: "seminuria", js: "seminuria", typ: u(undefined, i(0)) }, + { json: "tramp", js: "tramp", typ: u(undefined, i(0)) }, + { json: "undueness", js: "undueness", typ: u(undefined, i(0)) }, + { json: "worthily", js: "worthily", typ: u(undefined, i(0)) }, + ], false), + "TruantcyClass": o([ + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Epeira", js: "Epeira", typ: u(undefined, null) }, + { json: "Eurylaimi", js: "Eurylaimi", typ: u(undefined, null) }, + { json: "Yuman", js: "Yuman", typ: u(undefined, null) }, + { json: "alfiona", js: "alfiona", typ: u(undefined, null) }, + { json: "ascaridiasis", js: "ascaridiasis", typ: u(undefined, null) }, + { json: "bungey", js: "bungey", typ: u(undefined, null) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "ceroxyle", js: "ceroxyle", typ: u(undefined, null) }, + { json: "chorology", js: "chorology", typ: u(undefined, null) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "enmarble", js: "enmarble", typ: u(undefined, null) }, + { json: "germination", js: "germination", typ: u(undefined, null) }, + { json: "hallelujah", js: "hallelujah", typ: u(undefined, null) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "lev", js: "lev", typ: u(undefined, null) }, + { json: "mouthing", js: "mouthing", typ: u(undefined, null) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "philliloo", js: "philliloo", typ: u(undefined, null) }, + { json: "planetal", js: "planetal", typ: u(undefined, null) }, + { json: "poney", js: "poney", typ: u(undefined, null) }, + { json: "punctualist", js: "punctualist", typ: u(undefined, null) }, + { json: "returnlessly", js: "returnlessly", typ: u(undefined, null) }, + { json: "skelder", js: "skelder", typ: u(undefined, null) }, + { json: "windwaywardly", js: "windwaywardly", typ: u(undefined, null) }, + ], false), + "UnimpeachablyClass": o([ + { json: "Bobadil", js: "Bobadil", typ: u(undefined, i(0)) }, + { json: "Chirotherium", js: "Chirotherium", typ: u(undefined, i(0)) }, + { json: "Quiina", js: "Quiina", typ: u(undefined, i(0)) }, + { json: "Robert", js: "Robert", typ: u(undefined, i(0)) }, + { json: "acerin", js: "acerin", typ: u(undefined, i(0)) }, + { json: "catharticalness", js: "catharticalness", typ: u(undefined, 3.14) }, + { json: "chlorophylligenous", js: "chlorophylligenous", typ: u(undefined, i(0)) }, + { json: "conversational", js: "conversational", typ: u(undefined, i(0)) }, + { json: "demiowl", js: "demiowl", typ: u(undefined, i(0)) }, + { json: "disdiapason", js: "disdiapason", typ: u(undefined, "") }, + { json: "ectorhinal", js: "ectorhinal", typ: u(undefined, i(0)) }, + { json: "gamblesomeness", js: "gamblesomeness", typ: u(undefined, i(0)) }, + { json: "homocerc", js: "homocerc", typ: u(undefined, true) }, + { json: "irrorate", js: "irrorate", typ: u(undefined, i(0)) }, + { json: "kindergartening", js: "kindergartening", typ: u(undefined, i(0)) }, + { json: "lateritic", js: "lateritic", typ: u(undefined, i(0)) }, + { json: "mespil", js: "mespil", typ: u(undefined, i(0)) }, + { json: "misconfiguration", js: "misconfiguration", typ: u(undefined, i(0)) }, + { json: "nonbookish", js: "nonbookish", typ: u(undefined, null) }, + { json: "planometry", js: "planometry", typ: u(undefined, i(0)) }, + { json: "rot", js: "rot", typ: u(undefined, i(0)) }, + { json: "subcinctorium", js: "subcinctorium", typ: u(undefined, i(0)) }, + { json: "tussocker", js: "tussocker", typ: u(undefined, i(0)) }, + { json: "ultraproud", js: "ultraproud", typ: u(undefined, i(0)) }, + { json: "unsuggestedness", js: "unsuggestedness", typ: u(undefined, i(0)) }, + ], false), + "UnstressedClass": o([ + { json: "Alain", js: "Alain", typ: null }, + { json: "Amphirhina", js: "Amphirhina", typ: null }, + { json: "Lincolnian", js: "Lincolnian", typ: null }, + { json: "Sarcophilus", js: "Sarcophilus", typ: null }, + { json: "antimachinery", js: "antimachinery", typ: null }, + { json: "coldish", js: "coldish", typ: null }, + { json: "crantara", js: "crantara", typ: null }, + { json: "distinguishing", js: "distinguishing", typ: null }, + { json: "elytroposis", js: "elytroposis", typ: null }, + { json: "gentianwort", js: "gentianwort", typ: null }, + { json: "heliosis", js: "heliosis", typ: null }, + { json: "instrumental", js: "instrumental", typ: null }, + { json: "introinflection", js: "introinflection", typ: null }, + { json: "kala", js: "kala", typ: null }, + { json: "metad", js: "metad", typ: null }, + { json: "swingingly", js: "swingingly", typ: null }, + { json: "unconformity", js: "unconformity", typ: null }, + { json: "undecreed", js: "undecreed", typ: null }, + { json: "venerable", js: "venerable", typ: null }, + { json: "vowellessness", js: "vowellessness", typ: null }, + ], false), + "WrothyClass": o([ + { json: "Aeschynanthus", js: "Aeschynanthus", typ: null }, + { json: "Ephesine", js: "Ephesine", typ: null }, + { json: "aquiferous", js: "aquiferous", typ: null }, + { json: "cheapener", js: "cheapener", typ: null }, + { json: "enumeration", js: "enumeration", typ: null }, + { json: "escadrille", js: "escadrille", typ: null }, + { json: "estrous", js: "estrous", typ: null }, + { json: "interestedly", js: "interestedly", typ: null }, + { json: "katakinetomer", js: "katakinetomer", typ: null }, + { json: "mortification", js: "mortification", typ: null }, + { json: "morula", js: "morula", typ: null }, + { json: "orthosymmetrical", js: "orthosymmetrical", typ: null }, + { json: "overbark", js: "overbark", typ: null }, + { json: "politist", js: "politist", typ: null }, + { json: "qualified", js: "qualified", typ: null }, + { json: "sphenomalar", js: "sphenomalar", typ: null }, + { json: "throatful", js: "throatful", typ: null }, + { json: "transhumance", js: "transhumance", typ: null }, + { json: "triandrian", js: "triandrian", typ: null }, + { json: "unbooked", js: "unbooked", typ: null }, + ], false), +}; diff --git a/base/typescript/test/inputs/json/priority/combinations4.json/prefer-unions-false--a5053c0a486d/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations4.json/prefer-unions-false--a5053c0a486d/TopLevel.ts index bcc98d6..45c706b 100644 --- a/base/typescript/test/inputs/json/priority/combinations4.json/prefer-unions-false--a5053c0a486d/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations4.json/prefer-unions-false--a5053c0a486d/TopLevel.ts @@ -653,7 +653,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations4.json/prefer-unknown-false--f1ab9e45d823/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations4.json/prefer-unknown-false--f1ab9e45d823/TopLevel.ts index bcc98d6..45c706b 100644 --- a/base/typescript/test/inputs/json/priority/combinations4.json/prefer-unknown-false--f1ab9e45d823/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations4.json/prefer-unknown-false--f1ab9e45d823/TopLevel.ts @@ -653,7 +653,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations4.json/readonly-true--24da4fc107df/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations4.json/readonly-true--24da4fc107df/TopLevel.ts index cd22bee..cae9440 100644 --- a/base/typescript/test/inputs/json/priority/combinations4.json/readonly-true--24da4fc107df/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations4.json/readonly-true--24da4fc107df/TopLevel.ts @@ -653,7 +653,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combinations4.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.ts b/head/typescript/test/inputs/json/priority/combinations4.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.ts index 0d84084..f7bdc7b 100644 --- a/base/typescript/test/inputs/json/priority/combinations4.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combinations4.json/runtime-typecheck-ignore-unknown-properties-true--d792c40f022e/TopLevel.ts @@ -653,7 +653,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/combined-enum.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/combined-enum.json/default/TopLevel.ts index 55487ec..a3b736a 100644 --- a/base/typescript/test/inputs/json/priority/combined-enum.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/combined-enum.json/default/TopLevel.ts @@ -142,7 +142,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/direct-recursive.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/direct-recursive.json/default/TopLevel.ts index 4eb1ce6..c77bb4e 100644 --- a/base/typescript/test/inputs/json/priority/direct-recursive.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/direct-recursive.json/default/TopLevel.ts @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/empty-enum.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/empty-enum.json/default/TopLevel.ts index b55b9a5..6504ca6 100644 --- a/base/typescript/test/inputs/json/priority/empty-enum.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/empty-enum.json/default/TopLevel.ts @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/identifiers.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/identifiers.json/default/TopLevel.ts index bf8923e..242db77 100644 --- a/base/typescript/test/inputs/json/priority/identifiers.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/identifiers.json/default/TopLevel.ts @@ -163,7 +163,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/issue2680-object-array.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/issue2680-object-array.json/default/TopLevel.ts index 2b2615b..030d949 100644 --- a/base/typescript/test/inputs/json/priority/issue2680-object-array.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/issue2680-object-array.json/default/TopLevel.ts @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/issue2680-scalar-array.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/issue2680-scalar-array.json/default/TopLevel.ts index 3330b94..d71c1cf 100644 --- a/base/typescript/test/inputs/json/priority/issue2680-scalar-array.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/issue2680-scalar-array.json/default/TopLevel.ts @@ -133,7 +133,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/keywords.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/keywords.json/default/TopLevel.ts index 338246b..061db9c 100644 --- a/base/typescript/test/inputs/json/priority/keywords.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/keywords.json/default/TopLevel.ts @@ -1560,7 +1560,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/keywords.json/prefer-types-true--df33e18681f9/TopLevel.ts b/head/typescript/test/inputs/json/priority/keywords.json/prefer-types-true--df33e18681f9/TopLevel.ts index b6d855e..5d68533 100644 --- a/base/typescript/test/inputs/json/priority/keywords.json/prefer-types-true--df33e18681f9/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/keywords.json/prefer-types-true--df33e18681f9/TopLevel.ts @@ -1560,7 +1560,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/kotlin-enum-class-case-collision.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/kotlin-enum-class-case-collision.json/default/TopLevel.ts index fa56caf..b9b7cf4 100644 --- a/base/typescript/test/inputs/json/priority/kotlin-enum-class-case-collision.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/kotlin-enum-class-case-collision.json/default/TopLevel.ts @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/list.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/list.json/default/TopLevel.ts index 6e41c66..d68c498 100644 --- a/base/typescript/test/inputs/json/priority/list.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/list.json/default/TopLevel.ts @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/name-style.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/name-style.json/default/TopLevel.ts index c0192bd..ec3fd9a 100644 --- a/base/typescript/test/inputs/json/priority/name-style.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/name-style.json/default/TopLevel.ts @@ -141,7 +141,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/nbl-stats.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/nbl-stats.json/default/TopLevel.ts index 6ba8e8b..434e609 100644 --- a/base/typescript/test/inputs/json/priority/nbl-stats.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/nbl-stats.json/default/TopLevel.ts @@ -412,7 +412,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/nested-objects.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/nested-objects.json/default/TopLevel.ts index 781f37e..3630ec3 100644 --- a/base/typescript/test/inputs/json/priority/nested-objects.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/nested-objects.json/default/TopLevel.ts @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/no-classes.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/no-classes.json/default/TopLevel.ts index b927321..558bb8d 100644 --- a/base/typescript/test/inputs/json/priority/no-classes.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/no-classes.json/default/TopLevel.ts @@ -133,7 +133,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/nst-test-suite.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/nst-test-suite.json/default/TopLevel.ts index bf870c7..e0bdeb4 100644 --- a/base/typescript/test/inputs/json/priority/nst-test-suite.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/nst-test-suite.json/default/TopLevel.ts @@ -272,7 +272,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/number-map.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/number-map.json/default/TopLevel.ts index e8bfc7b..5a50cb2 100644 --- a/base/typescript/test/inputs/json/priority/number-map.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/number-map.json/default/TopLevel.ts @@ -135,7 +135,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/omit-empty.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/omit-empty.json/default/TopLevel.ts index d74f40b..31d6ae6 100644 --- a/base/typescript/test/inputs/json/priority/omit-empty.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/omit-empty.json/default/TopLevel.ts @@ -140,7 +140,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/optional-union.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/optional-union.json/default/TopLevel.ts index 9b98aa0..2f321b5 100644 --- a/base/typescript/test/inputs/json/priority/optional-union.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/optional-union.json/default/TopLevel.ts @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/php-mixed-union.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/php-mixed-union.json/default/TopLevel.ts index bacd1fe..0b4dd1c 100644 --- a/base/typescript/test/inputs/json/priority/php-mixed-union.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/php-mixed-union.json/default/TopLevel.ts @@ -141,7 +141,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/php-validation.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/php-validation.json/default/TopLevel.ts index 3b3c695..ebba414 100644 --- a/base/typescript/test/inputs/json/priority/php-validation.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/php-validation.json/default/TopLevel.ts @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/recursive.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/recursive.json/default/TopLevel.ts index 57e92a3..3d37b3f 100644 --- a/base/typescript/test/inputs/json/priority/recursive.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/recursive.json/default/TopLevel.ts @@ -254,7 +254,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/simple-identifiers.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/simple-identifiers.json/default/TopLevel.ts index 8ed09f6..4d76ae1 100644 --- a/base/typescript/test/inputs/json/priority/simple-identifiers.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/simple-identifiers.json/default/TopLevel.ts @@ -143,7 +143,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/union-constructor-clash.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/union-constructor-clash.json/default/TopLevel.ts index e0b99d6..aca9d66 100644 --- a/base/typescript/test/inputs/json/priority/union-constructor-clash.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/union-constructor-clash.json/default/TopLevel.ts @@ -142,7 +142,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/unions.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/unions.json/default/TopLevel.ts index 6ffd8bf..cd2e7e5 100644 --- a/base/typescript/test/inputs/json/priority/unions.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/unions.json/default/TopLevel.ts @@ -145,7 +145,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/url.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/url.json/default/TopLevel.ts index 79dc7b9..8b1dfed 100644 --- a/base/typescript/test/inputs/json/priority/url.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/url.json/default/TopLevel.ts @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/priority/uuids.json/default/TopLevel.ts b/head/typescript/test/inputs/json/priority/uuids.json/default/TopLevel.ts index 7918ec2..b837ec9 100644 --- a/base/typescript/test/inputs/json/priority/uuids.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/priority/uuids.json/default/TopLevel.ts @@ -141,7 +141,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (typeof typ === "object") { return typ.hasOwnProperty("uuid") ? typeof val === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(val) ? val : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/samples/bitcoin-block.json/default/TopLevel.ts b/head/typescript/test/inputs/json/samples/bitcoin-block.json/default/TopLevel.ts index e3c3c16..c1f1880 100644 --- a/base/typescript/test/inputs/json/samples/bitcoin-block.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/samples/bitcoin-block.json/default/TopLevel.ts @@ -139,7 +139,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/samples/copy-with-property.json/default/TopLevel.ts b/head/typescript/test/inputs/json/samples/copy-with-property.json/default/TopLevel.ts index 6f8fa3a..a5a6561 100644 --- a/base/typescript/test/inputs/json/samples/copy-with-property.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/samples/copy-with-property.json/default/TopLevel.ts @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/samples/getting-started.json/default/TopLevel.ts b/head/typescript/test/inputs/json/samples/getting-started.json/default/TopLevel.ts index 257b050..89a2554 100644 --- a/base/typescript/test/inputs/json/samples/getting-started.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/samples/getting-started.json/default/TopLevel.ts @@ -136,7 +136,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/samples/github-events.json/default/TopLevel.ts b/head/typescript/test/inputs/json/samples/github-events.json/default/TopLevel.ts index 2ca5bb2..69facab 100644 --- a/base/typescript/test/inputs/json/samples/github-events.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/samples/github-events.json/default/TopLevel.ts @@ -421,7 +421,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/samples/kitchen-sink.json/default/TopLevel.ts b/head/typescript/test/inputs/json/samples/kitchen-sink.json/default/TopLevel.ts index c81a5cf..3fd580f 100644 --- a/base/typescript/test/inputs/json/samples/kitchen-sink.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/samples/kitchen-sink.json/default/TopLevel.ts @@ -167,7 +167,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/samples/null-safe.json/default/TopLevel.ts b/head/typescript/test/inputs/json/samples/null-safe.json/default/TopLevel.ts index e0c3010..e63816f 100644 --- a/base/typescript/test/inputs/json/samples/null-safe.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/samples/null-safe.json/default/TopLevel.ts @@ -148,7 +148,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/samples/pokedex.json/default/TopLevel.ts b/head/typescript/test/inputs/json/samples/pokedex.json/default/TopLevel.ts index c4cb9ac..883e51c 100644 --- a/base/typescript/test/inputs/json/samples/pokedex.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/samples/pokedex.json/default/TopLevel.ts @@ -164,7 +164,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/samples/pokedex.json/prefer-types-true--df33e18681f9/TopLevel.ts b/head/typescript/test/inputs/json/samples/pokedex.json/prefer-types-true--df33e18681f9/TopLevel.ts index d496091..88a7d54 100644 --- a/base/typescript/test/inputs/json/samples/pokedex.json/prefer-types-true--df33e18681f9/TopLevel.ts +++ b/head/typescript/test/inputs/json/samples/pokedex.json/prefer-types-true--df33e18681f9/TopLevel.ts @@ -164,7 +164,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/samples/reddit.json/default/TopLevel.ts b/head/typescript/test/inputs/json/samples/reddit.json/default/TopLevel.ts index 273bdbe..31827e4 100644 --- a/base/typescript/test/inputs/json/samples/reddit.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/samples/reddit.json/default/TopLevel.ts @@ -261,7 +261,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/samples/simple-object.json/default/TopLevel.ts b/head/typescript/test/inputs/json/samples/simple-object.json/default/TopLevel.ts index 6485d85..c32d253 100644 --- a/base/typescript/test/inputs/json/samples/simple-object.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/samples/simple-object.json/default/TopLevel.ts @@ -137,7 +137,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/samples/spotify-album.json/default/TopLevel.ts b/head/typescript/test/inputs/json/samples/spotify-album.json/default/TopLevel.ts index 7015930..04f5e13 100644 --- a/base/typescript/test/inputs/json/samples/spotify-album.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/samples/spotify-album.json/default/TopLevel.ts @@ -205,7 +205,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/samples/us-avg-temperatures.json/default/TopLevel.ts b/head/typescript/test/inputs/json/samples/us-avg-temperatures.json/default/TopLevel.ts index b1c5823..4324306 100644 --- a/base/typescript/test/inputs/json/samples/us-avg-temperatures.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/samples/us-avg-temperatures.json/default/TopLevel.ts @@ -148,7 +148,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) diff --git a/base/typescript/test/inputs/json/samples/us-senators.json/default/TopLevel.ts b/head/typescript/test/inputs/json/samples/us-senators.json/default/TopLevel.ts index f86c46b..abc7d58 100644 --- a/base/typescript/test/inputs/json/samples/us-senators.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/samples/us-senators.json/default/TopLevel.ts @@ -217,7 +217,7 @@ function transform(val: any, typ: any, getProps: any, key: any = '', parent: any if (Array.isArray(typ)) return transformEnum(typ, val); if (typeof typ === "object") { return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) - : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || Array.from(val).length >= typ.min) && (typ.max === undefined || Array.from(val).length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val)