diff --git a/base/kotlin-jackson/test/inputs/json/misc/29f47.json/default/TopLevel.kt b/head/kotlin-jackson/test/inputs/json/misc/29f47.json/default/TopLevel.kt index a1a2465..e113e5e 100644 --- a/base/kotlin-jackson/test/inputs/json/misc/29f47.json/default/TopLevel.kt +++ b/head/kotlin-jackson/test/inputs/json/misc/29f47.json/default/TopLevel.kt @@ -299,9 +299,9 @@ sealed class Edited { companion object { fun fromJson(jn: JsonNode): Edited = when (jn) { - is BooleanNode -> BoolValue(mapper.treeToValue(jn)) - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is BooleanNode -> BoolValue(mapper.treeToValue(jn)) + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } diff --git a/base/kotlin-jackson/test/inputs/json/misc/a0496.json/default/TopLevel.kt b/head/kotlin-jackson/test/inputs/json/misc/a0496.json/default/TopLevel.kt index d14c162..e22cee3 100644 --- a/base/kotlin-jackson/test/inputs/json/misc/a0496.json/default/TopLevel.kt +++ b/head/kotlin-jackson/test/inputs/json/misc/a0496.json/default/TopLevel.kt @@ -107,10 +107,10 @@ sealed class Datum { companion object { fun fromJson(jn: JsonNode): Datum = when (jn) { - is TextNode -> DateValue(mapper.treeToValue(jn)) - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - null -> NullValue() - else -> throw IllegalArgumentException() + is TextNode -> DateValue(mapper.treeToValue(jn)) + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + null -> NullValue() + else -> throw IllegalArgumentException() } } } diff --git a/base/kotlin-jackson/test/inputs/json/priority/combinations1.json/default/TopLevel.kt b/head/kotlin-jackson/test/inputs/json/priority/combinations1.json/default/TopLevel.kt index aa0bbdc..a8dc548 100644 --- a/base/kotlin-jackson/test/inputs/json/priority/combinations1.json/default/TopLevel.kt +++ b/head/kotlin-jackson/test/inputs/json/priority/combinations1.json/default/TopLevel.kt @@ -346,9 +346,9 @@ sealed class Clinodome { companion object { fun fromJson(jn: JsonNode): Clinodome = when (jn) { - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is TextNode -> StringValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is TextNode -> StringValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } @@ -364,9 +364,9 @@ sealed class CoadjustElement { companion object { fun fromJson(jn: JsonNode): CoadjustElement = when (jn) { - is ObjectNode -> CoadjustClassValue(mapper.treeToValue(jn)) - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is ObjectNode -> CoadjustClassValue(mapper.treeToValue(jn)) + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } @@ -425,9 +425,9 @@ sealed class Consilience { companion object { fun fromJson(jn: JsonNode): Consilience = when (jn) { - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is ObjectNode -> IntegerMapValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is ObjectNode -> IntegerMapValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } @@ -674,10 +674,10 @@ sealed class Eleutheromania { companion object { fun fromJson(jn: JsonNode): Eleutheromania = when (jn) { - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is ObjectNode -> IntegerMapValue(mapper.treeToValue(jn)) - is TextNode -> StringValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is ObjectNode -> IntegerMapValue(mapper.treeToValue(jn)) + is TextNode -> StringValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } @@ -744,9 +744,9 @@ sealed class Epipaleolithic { companion object { fun fromJson(jn: JsonNode): Epipaleolithic = when (jn) { - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is ArrayNode -> IntegerArrayValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is ArrayNode -> IntegerArrayValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } @@ -764,10 +764,10 @@ sealed class Expropriable { companion object { fun fromJson(jn: JsonNode): Expropriable = when (jn) { - is ObjectNode -> CimeliaClassValue(mapper.treeToValue(jn)) - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is ArrayNode -> NullArrayValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is ObjectNode -> CimeliaClassValue(mapper.treeToValue(jn)) + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is ArrayNode -> NullArrayValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } @@ -783,9 +783,9 @@ sealed class FagginglyElement { companion object { fun fromJson(jn: JsonNode): FagginglyElement = when (jn) { - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is ObjectNode -> FagginglyClassValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is ObjectNode -> FagginglyClassValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } @@ -888,10 +888,10 @@ sealed class FlagmakingElement { companion object { fun fromJson(jn: JsonNode): FlagmakingElement = when (jn) { - is BooleanNode -> BoolValue(mapper.treeToValue(jn)) - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is ObjectNode -> FlagmakingClassValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is BooleanNode -> BoolValue(mapper.treeToValue(jn)) + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is ObjectNode -> FlagmakingClassValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } @@ -1196,10 +1196,10 @@ sealed class Intentiveness { companion object { fun fromJson(jn: JsonNode): Intentiveness = when (jn) { - is ObjectNode -> CimeliaClassValue(mapper.treeToValue(jn)) - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is TextNode -> StringValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is ObjectNode -> CimeliaClassValue(mapper.treeToValue(jn)) + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is TextNode -> StringValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } diff --git a/head/ruby/test/inputs/json/priority/combinations2.json/default/TopLevel.rb b/head/ruby/test/inputs/json/priority/combinations2.json/default/TopLevel.rb new file mode 100644 index 0000000..06a7950 --- /dev/null +++ b/head/ruby/test/inputs/json/priority/combinations2.json/default/TopLevel.rb @@ -0,0 +1,2292 @@ +# This code may look unusually verbose for Ruby (and it is), but +# it performs some subtle and complex validation of JSON data. +# +# To parse this JSON, add 'dry-struct' and 'dry-types' gems, then do: +# +# top_level = TopLevel.from_json! "{…}" +# puts top_level.wayao["…"] +# +# If from_json! succeeds, the value returned matches the schema. + +require 'json' +require 'dry-types' +require 'dry-struct' + +module Types + include Dry.Types(default: :nominal) + + Integer = Strict::Integer + Nil = Strict::Nil + Bool = Strict::Bool + Hash = Strict::Hash + String = Strict::String + Double = Strict::Float | Strict::Integer +end + +class Abranchiata < Dry::Struct + attribute :integer, Types::Integer.optional + attribute :integer_array, Types.Array(Types::Integer).optional + attribute :null, Types::Nil.optional + + def self.from_dynamic!(d) + if schema[:integer].right.valid? d + return new(integer: d, integer_array: nil, null: nil) + end + if schema[:integer_array].right.valid? d + return new(integer_array: d, integer: nil, null: nil) + end + if schema[:null].right.valid? d + return new(null: d, integer_array: nil, integer: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer != nil + integer + elsif integer_array != nil + integer_array + else + nil + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Academe < Dry::Struct + attribute :integer, Types::Integer.optional + attribute :integer_array, Types.Array(Types::Integer).optional + attribute :integer_map, Types::Hash.meta(of: Types::Integer).optional + + def self.from_dynamic!(d) + if schema[:integer].right.valid? d + return new(integer: d, integer_array: nil, integer_map: nil) + end + if schema[:integer_array].right.valid? d + return new(integer_array: d, integer: nil, integer_map: nil) + end + begin + value = Types::Hash[d].map { |k, v| [k, Types::Integer[v]] }.to_h + if schema[:integer_map].right.valid? value + return new(integer_map: value, integer_array: nil, integer: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer != nil + integer + elsif integer_array != nil + integer_array + elsif integer_map != nil + integer_map + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Acquirable < Dry::Struct + attribute :integer_map, Types::Hash.meta(of: Types::Integer).optional + attribute :union_array, Types.Array(Types::Integer.optional).optional + + def self.from_dynamic!(d) + begin + value = Types::Hash[d].map { |k, v| [k, Types::Integer[v]] }.to_h + if schema[:integer_map].right.valid? value + return new(integer_map: value, union_array: nil) + end + rescue + end + if schema[:union_array].right.valid? d + return new(union_array: d, integer_map: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer_map != nil + integer_map + elsif union_array != nil + union_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Aerometry < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :double, Types::Double.optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, double: nil) + end + if schema[:double].right.valid? d + return new(double: d, bool: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif double != nil + double + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Alexin < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :integer_array, Types.Array(Types::Integer).optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, integer_array: nil) + end + if schema[:integer_array].right.valid? d + return new(integer_array: d, bool: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif integer_array != nil + integer_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class AlleviateClass < Dry::Struct + attribute :apriori, Types::Nil + attribute :beggarer, Types::Nil + attribute :brokenheartedly, Types::Nil + attribute :debilitation, Types::Nil + attribute :frike, Types::Nil + attribute :gastrolith, Types::Nil + attribute :hulsean, Types::Nil + attribute :orthocentric, Types::Nil + attribute :petaly, Types::Nil + attribute :probudgeting, Types::Nil + attribute :reacquire, Types::Nil + attribute :scow, Types::Nil + attribute :shutoff, Types::Nil + attribute :subcontiguous, Types::Nil + attribute :suffumigate, Types::Nil + attribute :transformable, Types::Nil + attribute :uncoroneted, Types::Nil + attribute :unparking, Types::Nil + attribute :unvarnishedness, Types::Nil + attribute :wherewithal, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + apriori: d.fetch("apriori"), + beggarer: d.fetch("beggarer"), + brokenheartedly: d.fetch("brokenheartedly"), + debilitation: d.fetch("debilitation"), + frike: d.fetch("frike"), + gastrolith: d.fetch("gastrolith"), + hulsean: d.fetch("Hulsean"), + orthocentric: d.fetch("orthocentric"), + petaly: d.fetch("petaly"), + probudgeting: d.fetch("probudgeting"), + reacquire: d.fetch("reacquire"), + scow: d.fetch("scow"), + shutoff: d.fetch("shutoff"), + subcontiguous: d.fetch("subcontiguous"), + suffumigate: d.fetch("suffumigate"), + transformable: d.fetch("transformable"), + uncoroneted: d.fetch("uncoroneted"), + unparking: d.fetch("unparking"), + unvarnishedness: d.fetch("unvarnishedness"), + wherewithal: d.fetch("wherewithal"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class AlleviateElement < Dry::Struct + attribute :alleviate_class, AlleviateClass.optional + attribute :union_array, Types.Array(Types::Integer.optional).optional + + def self.from_dynamic!(d) + begin + value = AlleviateClass.from_dynamic!(d) + if schema[:alleviate_class].right.valid? value + return new(alleviate_class: value, union_array: nil) + end + rescue + end + if schema[:union_array].right.valid? d + return new(union_array: d, alleviate_class: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if alleviate_class != nil + alleviate_class.to_dynamic + elsif union_array != nil + union_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Rebecca < Dry::Struct + attribute :catharticalness, Types::Double + attribute :chirotherium, Types::Integer + attribute :disdiapason, Types::String + attribute :homocerc, Types::Bool + attribute :nonbookish, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + catharticalness: d.fetch("catharticalness"), + chirotherium: d.fetch("Chirotherium"), + disdiapason: d.fetch("disdiapason"), + homocerc: d.fetch("homocerc"), + nonbookish: d.fetch("nonbookish"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "catharticalness" => catharticalness, + "Chirotherium" => chirotherium, + "disdiapason" => disdiapason, + "homocerc" => homocerc, + "nonbookish" => nonbookish, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Amaa < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :integer, Types::Integer.optional + attribute :rebecca, Rebecca.optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, rebecca: nil, integer: nil) + end + if schema[:integer].right.valid? d + return new(integer: d, bool: nil, rebecca: nil) + end + begin + value = Rebecca.from_dynamic!(d) + if schema[:rebecca].right.valid? value + return new(rebecca: value, bool: nil, integer: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif integer != nil + integer + elsif rebecca != nil + rebecca.to_dynamic + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Ambassage < Dry::Struct + attribute :null_array, Types.Array(Types::Nil).optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + if schema[:null_array].right.valid? d + return new(null_array: d, string: nil) + end + if schema[:string].right.valid? d + return new(string: d, null_array: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if null_array != nil + null_array + elsif string != nil + string + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Amphithyron < Dry::Struct + attribute :akroasis, Types::Integer.optional + attribute :antiphonical, Types::Integer.optional + attribute :basebred, Types::Integer.optional + attribute :catharticalness, Types::Double.optional + attribute :chirotherium, Types::Integer.optional + attribute :conductometric, Types::Integer.optional + attribute :disdiapason, Types::String.optional + attribute :ensilation, Types::Integer.optional + attribute :eyebolt, Types::Integer.optional + attribute :fistulated, Types::Integer.optional + attribute :heteropod, Types::Integer.optional + attribute :homocerc, Types::Bool.optional + attribute :juniperus, Types::Integer.optional + attribute :labyrinthically, Types::Integer.optional + attribute :martyrization, Types::Integer.optional + attribute :mispolicy, Types::Integer.optional + attribute :multipara, Types::Integer.optional + attribute :nazirite, Types::Integer.optional + attribute :nonbookish, Types::Nil.optional + attribute :possessorial, Types::Integer.optional + attribute :shamed, Types::Integer.optional + attribute :shelfworn, Types::Integer.optional + attribute :stagnum, Types::Integer.optional + attribute :those, Types::Integer.optional + attribute :undecimal, Types::Integer.optional + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + akroasis: d["akroasis"], + antiphonical: d["antiphonical"], + basebred: d["basebred"], + catharticalness: d["catharticalness"], + chirotherium: d["Chirotherium"], + conductometric: d["conductometric"], + disdiapason: d["disdiapason"], + ensilation: d["ensilation"], + eyebolt: d["eyebolt"], + fistulated: d["fistulated"], + heteropod: d["heteropod"], + homocerc: d["homocerc"], + juniperus: d["Juniperus"], + labyrinthically: d["labyrinthically"], + martyrization: d["martyrization"], + mispolicy: d["mispolicy"], + multipara: d["multipara"], + nazirite: d["Nazirite"], + nonbookish: d["nonbookish"], + possessorial: d["possessorial"], + shamed: d["shamed"], + shelfworn: d["shelfworn"], + stagnum: d["stagnum"], + those: d["Those"], + undecimal: d["undecimal"], + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class AnkeeClass < Dry::Struct + attribute :anomoean, Types::Nil + attribute :barleyhood, Types::Nil + attribute :befriender, Types::Nil + attribute :brutishness, Types::Nil + attribute :cephalalgy, Types::Nil + attribute :cirurgian, Types::Nil + attribute :conventionally, Types::Nil + attribute :jackshay, Types::Nil + attribute :milammeter, Types::Nil + attribute :naja, Types::Nil + attribute :ombrological, Types::Nil + attribute :phonasthenia, Types::Nil + attribute :retrievableness, Types::Nil + attribute :snakily, Types::Nil + attribute :swot, Types::Nil + attribute :tartlet, Types::Nil + attribute :thiofuran, Types::Nil + attribute :tracheophone, Types::Nil + attribute :tuglike, Types::Nil + attribute :unscratchingly, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + anomoean: d.fetch("Anomoean"), + barleyhood: d.fetch("barleyhood"), + befriender: d.fetch("befriender"), + brutishness: d.fetch("brutishness"), + cephalalgy: d.fetch("cephalalgy"), + cirurgian: d.fetch("cirurgian"), + conventionally: d.fetch("conventionally"), + jackshay: d.fetch("jackshay"), + milammeter: d.fetch("milammeter"), + naja: d.fetch("Naja"), + ombrological: d.fetch("ombrological"), + phonasthenia: d.fetch("phonasthenia"), + retrievableness: d.fetch("retrievableness"), + snakily: d.fetch("snakily"), + swot: d.fetch("swot"), + tartlet: d.fetch("tartlet"), + thiofuran: d.fetch("thiofuran"), + tracheophone: d.fetch("tracheophone"), + tuglike: d.fetch("tuglike"), + unscratchingly: d.fetch("unscratchingly"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class AnkeeElement < Dry::Struct + attribute :ankee_class, AnkeeClass.optional + attribute :integer, Types::Integer.optional + attribute :integer_array, Types.Array(Types::Integer).optional + + def self.from_dynamic!(d) + begin + value = AnkeeClass.from_dynamic!(d) + if schema[:ankee_class].right.valid? value + return new(ankee_class: value, integer_array: nil, integer: nil) + end + rescue + end + if schema[:integer].right.valid? d + return new(integer: d, integer_array: nil, ankee_class: nil) + end + if schema[:integer_array].right.valid? d + return new(integer_array: d, ankee_class: nil, integer: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if ankee_class != nil + ankee_class.to_dynamic + elsif integer != nil + integer + elsif integer_array != nil + integer_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class AnsarieClass < Dry::Struct + attribute :accension, Types::Nil + attribute :alida, Types::Nil + attribute :asteria, Types::Nil + attribute :beriberic, Types::Nil + attribute :edgebone, Types::Nil + attribute :gastrodialysis, Types::Nil + attribute :geographic, Types::Nil + attribute :ictonyx, Types::Nil + attribute :metrocele, Types::Nil + attribute :misgraft, Types::Nil + attribute :monteith, Types::Nil + attribute :notcher, Types::Nil + attribute :prorestriction, Types::Nil + attribute :ramist, Types::Nil + attribute :throatlet, Types::Nil + attribute :unfair, Types::Nil + attribute :unsynonymous, Types::Nil + attribute :water, Types::Nil + attribute :zestfully, Types::Nil + attribute :zincic, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + accension: d.fetch("accension"), + alida: d.fetch("Alida"), + asteria: d.fetch("asteria"), + beriberic: d.fetch("beriberic"), + edgebone: d.fetch("edgebone"), + gastrodialysis: d.fetch("gastrodialysis"), + geographic: d.fetch("geographic"), + ictonyx: d.fetch("Ictonyx"), + metrocele: d.fetch("metrocele"), + misgraft: d.fetch("misgraft"), + monteith: d.fetch("monteith"), + notcher: d.fetch("notcher"), + prorestriction: d.fetch("prorestriction"), + ramist: d.fetch("Ramist"), + throatlet: d.fetch("throatlet"), + unfair: d.fetch("unfair"), + unsynonymous: d.fetch("unsynonymous"), + water: d.fetch("water"), + zestfully: d.fetch("zestfully"), + zincic: d.fetch("zincic"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class AnsarieElement < Dry::Struct + attribute :ansarie_class, AnsarieClass.optional + attribute :integer_array, Types.Array(Types::Integer).optional + attribute :null, Types::Nil.optional + + def self.from_dynamic!(d) + begin + value = AnsarieClass.from_dynamic!(d) + if schema[:ansarie_class].right.valid? value + return new(ansarie_class: value, integer_array: nil, null: nil) + end + rescue + end + if schema[:integer_array].right.valid? d + return new(integer_array: d, ansarie_class: nil, null: nil) + end + if schema[:null].right.valid? d + return new(null: d, integer_array: nil, ansarie_class: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if ansarie_class != nil + ansarie_class.to_dynamic + elsif integer_array != nil + integer_array + else + nil + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Aphasia < Dry::Struct + attribute :integer, Types::Integer.optional + attribute :integer_array, Types.Array(Types::Integer).optional + + def self.from_dynamic!(d) + if schema[:integer].right.valid? d + return new(integer: d, integer_array: nil) + end + if schema[:integer_array].right.valid? d + return new(integer_array: d, integer: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer != nil + integer + elsif integer_array != nil + integer_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Asprawl < Dry::Struct + attribute :double, Types::Double.optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, string: nil) + end + if schema[:string].right.valid? d + return new(string: d, double: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif string != nil + string + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Bedesman < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :double, Types::Double.optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, double: nil, string: nil) + end + if schema[:double].right.valid? d + return new(double: d, bool: nil, string: nil) + end + if schema[:string].right.valid? d + return new(string: d, bool: nil, double: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif double != nil + double + elsif string != nil + string + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Belard < Dry::Struct + attribute :double, Types::Double.optional + attribute :integer_array, Types.Array(Types::Integer).optional + attribute :rebecca, Rebecca.optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, integer_array: nil, rebecca: nil) + end + if schema[:integer_array].right.valid? d + return new(integer_array: d, rebecca: nil, double: nil) + end + begin + value = Rebecca.from_dynamic!(d) + if schema[:rebecca].right.valid? value + return new(rebecca: value, integer_array: nil, double: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif integer_array != nil + integer_array + elsif rebecca != nil + rebecca.to_dynamic + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Bocking < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :integer_array, Types.Array(Types::Integer).optional + attribute :integer_map, Types::Hash.meta(of: Types::Integer).optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, integer_array: nil, integer_map: nil) + end + if schema[:integer_array].right.valid? d + return new(integer_array: d, bool: nil, integer_map: nil) + end + begin + value = Types::Hash[d].map { |k, v| [k, Types::Integer[v]] }.to_h + if schema[:integer_map].right.valid? value + return new(integer_map: value, integer_array: nil, bool: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif integer_array != nil + integer_array + elsif integer_map != nil + integer_map + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Brawlingly < Dry::Struct + attribute :null_array, Types.Array(Types::Nil).optional + attribute :union_map, Types::Hash.meta(of: Types::Integer.optional).optional + + def self.from_dynamic!(d) + if schema[:null_array].right.valid? d + return new(null_array: d, union_map: nil) + end + begin + value = Types::Hash[d].map { |k, v| [k, v] }.to_h + if schema[:union_map].right.valid? value + return new(union_map: value, null_array: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if null_array != nil + null_array + elsif union_map != nil + union_map + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Brookie < Dry::Struct + attribute :integer_array, Types.Array(Types::Integer).optional + attribute :rebecca, Rebecca.optional + + def self.from_dynamic!(d) + if schema[:integer_array].right.valid? d + return new(integer_array: d, rebecca: nil) + end + begin + value = Rebecca.from_dynamic!(d) + if schema[:rebecca].right.valid? value + return new(rebecca: value, integer_array: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer_array != nil + integer_array + elsif rebecca != nil + rebecca.to_dynamic + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Bumboatman < Dry::Struct + attribute :null, Types::Nil.optional + attribute :null_array, Types.Array(Types::Nil).optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + if schema[:null].right.valid? d + return new(null: d, null_array: nil, string: nil) + end + if schema[:null_array].right.valid? d + return new(null_array: d, null: nil, string: nil) + end + if schema[:string].right.valid? d + return new(string: d, null_array: nil, null: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if null_array != nil + null_array + elsif string != nil + string + else + nil + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Calaverite < Dry::Struct + attribute :integer_array, Types.Array(Types::Integer).optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + if schema[:integer_array].right.valid? d + return new(integer_array: d, string: nil) + end + if schema[:string].right.valid? d + return new(string: d, integer_array: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer_array != nil + integer_array + elsif string != nil + string + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Catallactic < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :integer_map, Types::Hash.meta(of: Types::Integer).optional + attribute :null_array, Types.Array(Types::Nil).optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, null_array: nil, integer_map: nil) + end + begin + value = Types::Hash[d].map { |k, v| [k, Types::Integer[v]] }.to_h + if schema[:integer_map].right.valid? value + return new(integer_map: value, null_array: nil, bool: nil) + end + rescue + end + if schema[:null_array].right.valid? d + return new(null_array: d, bool: nil, integer_map: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif integer_map != nil + integer_map + elsif null_array != nil + null_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Cemental < Dry::Struct + attribute :double, Types::Double.optional + attribute :integer_array, Types.Array(Types::Integer).optional + attribute :integer_map, Types::Hash.meta(of: Types::Integer).optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, integer_array: nil, integer_map: nil) + end + if schema[:integer_array].right.valid? d + return new(integer_array: d, double: nil, integer_map: nil) + end + begin + value = Types::Hash[d].map { |k, v| [k, Types::Integer[v]] }.to_h + if schema[:integer_map].right.valid? value + return new(integer_map: value, integer_array: nil, double: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif integer_array != nil + integer_array + elsif integer_map != nil + integer_map + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class ChytridiaceaeClass < Dry::Struct + attribute :batidaceae, Types::Nil + attribute :brechites, Types::Nil + attribute :codespairer, Types::Nil + attribute :emery, Types::Nil + attribute :enervative, Types::Nil + attribute :excriminate, Types::Nil + attribute :goshenite, Types::Nil + attribute :grime, Types::Nil + attribute :gritten, Types::Nil + attribute :hectorly, Types::Nil + attribute :intermediation, Types::Nil + attribute :meeterly, Types::Nil + attribute :narraganset, Types::Nil + attribute :onymatic, Types::Nil + attribute :paddlecock, Types::Nil + attribute :thana, Types::Nil + attribute :thornily, Types::Nil + attribute :uckia, Types::Nil + attribute :unmettle, Types::Nil + attribute :vorticellid, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + batidaceae: d.fetch("Batidaceae"), + brechites: d.fetch("Brechites"), + codespairer: d.fetch("codespairer"), + emery: d.fetch("Emery"), + enervative: d.fetch("enervative"), + excriminate: d.fetch("excriminate"), + goshenite: d.fetch("goshenite"), + grime: d.fetch("grime"), + gritten: d.fetch("gritten"), + hectorly: d.fetch("hectorly"), + intermediation: d.fetch("intermediation"), + meeterly: d.fetch("meeterly"), + narraganset: d.fetch("Narraganset"), + onymatic: d.fetch("onymatic"), + paddlecock: d.fetch("paddlecock"), + thana: d.fetch("thana"), + thornily: d.fetch("thornily"), + uckia: d.fetch("uckia"), + unmettle: d.fetch("unmettle"), + vorticellid: d.fetch("vorticellid"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class ChytridiaceaeElement < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :chytridiaceae_class, ChytridiaceaeClass.optional + attribute :null, Types::Nil.optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, chytridiaceae_class: nil, null: nil) + end + begin + value = ChytridiaceaeClass.from_dynamic!(d) + if schema[:chytridiaceae_class].right.valid? value + return new(chytridiaceae_class: value, bool: nil, null: nil) + end + rescue + end + if schema[:null].right.valid? d + return new(null: d, bool: nil, chytridiaceae_class: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif chytridiaceae_class != nil + chytridiaceae_class.to_dynamic + else + nil + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class DiscordiaClass < Dry::Struct + attribute :altaic, Types::Integer.optional + attribute :amoristic, Types::Integer.optional + attribute :blennophthalmia, Types::Integer.optional + attribute :catharticalness, Types::Double.optional + attribute :chirotherium, Types::Integer.optional + attribute :disciplinability, Types::Integer.optional + attribute :disdiapason, Types::String.optional + attribute :goofer, Types::Integer.optional + attribute :homocerc, Types::Bool.optional + attribute :laryngograph, Types::Integer.optional + attribute :leucitis, Types::Integer.optional + attribute :lymphocyst, Types::Integer.optional + attribute :microcosmology, Types::Integer.optional + attribute :nauseation, Types::Integer.optional + attribute :nonbookish, Types::Nil.optional + attribute :patarin, Types::Integer.optional + attribute :preliberal, Types::Integer.optional + attribute :prettifier, Types::Integer.optional + attribute :rangework, Types::Integer.optional + attribute :redient, Types::Integer.optional + attribute :subfusiform, Types::Integer.optional + attribute :suicidical, Types::Integer.optional + attribute :swow, Types::Integer.optional + attribute :wastrel, Types::Integer.optional + attribute :wingle, Types::Integer.optional + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + altaic: d["Altaic"], + amoristic: d["amoristic"], + blennophthalmia: d["blennophthalmia"], + catharticalness: d["catharticalness"], + chirotherium: d["Chirotherium"], + disciplinability: d["disciplinability"], + disdiapason: d["disdiapason"], + goofer: d["goofer"], + homocerc: d["homocerc"], + laryngograph: d["laryngograph"], + leucitis: d["leucitis"], + lymphocyst: d["lymphocyst"], + microcosmology: d["microcosmology"], + nauseation: d["nauseation"], + nonbookish: d["nonbookish"], + patarin: d["Patarin"], + preliberal: d["preliberal"], + prettifier: d["prettifier"], + rangework: d["rangework"], + redient: d["redient"], + subfusiform: d["subfusiform"], + suicidical: d["suicidical"], + swow: d["swow"], + wastrel: d["wastrel"], + wingle: d["wingle"], + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class DiscordiaElement < Dry::Struct + attribute :discordia_class, DiscordiaClass.optional + attribute :integer_array, Types.Array(Types::Integer).optional + + def self.from_dynamic!(d) + begin + value = DiscordiaClass.from_dynamic!(d) + if schema[:discordia_class].right.valid? value + return new(discordia_class: value, integer_array: nil) + end + rescue + end + if schema[:integer_array].right.valid? d + return new(integer_array: d, discordia_class: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if discordia_class != nil + discordia_class.to_dynamic + elsif integer_array != nil + integer_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Endomyce < Dry::Struct + attribute :integer, Types::Integer.optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + if schema[:integer].right.valid? d + return new(integer: d, string: nil) + end + if schema[:string].right.valid? d + return new(string: d, integer: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer != nil + integer + elsif string != nil + string + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Epinephelidae < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :integer, Types::Integer.optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, integer: nil, string: nil) + end + if schema[:integer].right.valid? d + return new(integer: d, bool: nil, string: nil) + end + if schema[:string].right.valid? d + return new(string: d, bool: nil, integer: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif integer != nil + integer + elsif string != nil + string + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Eupatorium < Dry::Struct + attribute :integer_map, Types::Hash.meta(of: Types::Integer).optional + attribute :null_array, Types.Array(Types::Nil).optional + + def self.from_dynamic!(d) + begin + value = Types::Hash[d].map { |k, v| [k, Types::Integer[v]] }.to_h + if schema[:integer_map].right.valid? value + return new(integer_map: value, null_array: nil) + end + rescue + end + if schema[:null_array].right.valid? d + return new(null_array: d, integer_map: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer_map != nil + integer_map + elsif null_array != nil + null_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class GryphosaurusClass < Dry::Struct + attribute :amissibility, Types::Nil + attribute :burushaski, Types::Nil + attribute :citronin, Types::Nil + attribute :coplaintiff, Types::Nil + attribute :disquisitionary, Types::Nil + attribute :enoplan, Types::Nil + attribute :faintness, Types::Nil + attribute :hebetomy, Types::Nil + attribute :islandry, Types::Nil + attribute :lameduck, Types::Nil + attribute :overbattle, Types::Nil + attribute :overinterested, Types::Nil + attribute :phrenologic, Types::Nil + attribute :rainband, Types::Nil + attribute :shiningly, Types::Nil + attribute :stamineous, Types::Nil + attribute :subscapularis, Types::Nil + attribute :tahami, Types::Nil + attribute :undaubed, Types::Nil + attribute :underntime, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + amissibility: d.fetch("amissibility"), + burushaski: d.fetch("Burushaski"), + citronin: d.fetch("citronin"), + coplaintiff: d.fetch("coplaintiff"), + disquisitionary: d.fetch("disquisitionary"), + enoplan: d.fetch("enoplan"), + faintness: d.fetch("faintness"), + hebetomy: d.fetch("hebetomy"), + islandry: d.fetch("islandry"), + lameduck: d.fetch("lameduck"), + overbattle: d.fetch("overbattle"), + overinterested: d.fetch("overinterested"), + phrenologic: d.fetch("phrenologic"), + rainband: d.fetch("rainband"), + shiningly: d.fetch("shiningly"), + stamineous: d.fetch("stamineous"), + subscapularis: d.fetch("subscapularis"), + tahami: d.fetch("Tahami"), + undaubed: d.fetch("undaubed"), + underntime: d.fetch("underntime"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class GryphosaurusElement < Dry::Struct + attribute :gryphosaurus_class, GryphosaurusClass.optional + attribute :integer_array, Types.Array(Types::Integer).optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + begin + value = GryphosaurusClass.from_dynamic!(d) + if schema[:gryphosaurus_class].right.valid? value + return new(gryphosaurus_class: value, integer_array: nil, string: nil) + end + rescue + end + if schema[:integer_array].right.valid? d + return new(integer_array: d, gryphosaurus_class: nil, string: nil) + end + if schema[:string].right.valid? d + return new(string: d, integer_array: nil, gryphosaurus_class: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if gryphosaurus_class != nil + gryphosaurus_class.to_dynamic + elsif integer_array != nil + integer_array + elsif string != nil + string + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Koryak < Dry::Struct + attribute :string, Types::String.optional + attribute :union_map, Types::Hash.meta(of: Types::Integer.optional).optional + + def self.from_dynamic!(d) + if schema[:string].right.valid? d + return new(string: d, union_map: nil) + end + begin + value = Types::Hash[d].map { |k, v| [k, v] }.to_h + if schema[:union_map].right.valid? value + return new(union_map: value, string: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if string != nil + string + elsif union_map != nil + union_map + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class LaviniaClass < Dry::Struct + attribute :agitable, Types::Integer.optional + attribute :asininity, Types::Integer.optional + attribute :benefiter, Types::Integer.optional + attribute :bronzelike, Types::Integer.optional + attribute :catharticalness, Types::Double.optional + attribute :chirotherium, Types::Integer.optional + attribute :cholesteatomatous, Types::Integer.optional + attribute :deprivement, Types::Integer.optional + attribute :disdiapason, Types::String.optional + attribute :flippantness, Types::Integer.optional + attribute :fogproof, Types::Integer.optional + attribute :homocerc, Types::Bool.optional + attribute :merrymeeting, Types::Integer.optional + attribute :nonbookish, Types::Nil.optional + attribute :overcareful, Types::Integer.optional + attribute :panaris, Types::Integer.optional + attribute :preacceptance, Types::Integer.optional + attribute :quinoxaline, Types::Integer.optional + attribute :sig, Types::Integer.optional + attribute :superconfusion, Types::Integer.optional + attribute :tacana, Types::Integer.optional + attribute :tillotter, Types::Integer.optional + attribute :tranquillize, Types::Integer.optional + attribute :unquestionable, Types::Integer.optional + attribute :uproute, Types::Integer.optional + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + agitable: d["agitable"], + asininity: d["asininity"], + benefiter: d["benefiter"], + bronzelike: d["bronzelike"], + catharticalness: d["catharticalness"], + chirotherium: d["Chirotherium"], + cholesteatomatous: d["cholesteatomatous"], + deprivement: d["deprivement"], + disdiapason: d["disdiapason"], + flippantness: d["flippantness"], + fogproof: d["fogproof"], + homocerc: d["homocerc"], + merrymeeting: d["merrymeeting"], + nonbookish: d["nonbookish"], + overcareful: d["overcareful"], + panaris: d["panaris"], + preacceptance: d["preacceptance"], + quinoxaline: d["quinoxaline"], + sig: d["sig"], + superconfusion: d["superconfusion"], + tacana: d["Tacana"], + tillotter: d["tillotter"], + tranquillize: d["tranquillize"], + unquestionable: d["unquestionable"], + uproute: d["uproute"], + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class LaviniaElement < Dry::Struct + attribute :lavinia_class, LaviniaClass.optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + begin + value = LaviniaClass.from_dynamic!(d) + if schema[:lavinia_class].right.valid? value + return new(lavinia_class: value, string: nil) + end + rescue + end + if schema[:string].right.valid? d + return new(string: d, lavinia_class: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if lavinia_class != nil + lavinia_class.to_dynamic + elsif string != nil + string + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class OskarClass < Dry::Struct + attribute :acrobates, Types::Nil + attribute :beanshooter, Types::Nil + attribute :bearhound, Types::Nil + attribute :cayuga, Types::Nil + attribute :guarneri, Types::Nil + attribute :hypochondriacism, Types::Nil + attribute :indication, Types::Nil + attribute :jaculative, Types::Nil + attribute :nagana, Types::Nil + attribute :netherlandish, Types::Nil + attribute :noctivagous, Types::Nil + attribute :nonphysiological, Types::Nil + attribute :praxis, Types::Nil + attribute :provision, Types::Nil + attribute :subterhuman, Types::Nil + attribute :sunlit, Types::Nil + attribute :syncraniate, Types::Nil + attribute :teachment, Types::Nil + attribute :unmutinous, Types::Nil + attribute :unstoppable, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + acrobates: d.fetch("Acrobates"), + beanshooter: d.fetch("beanshooter"), + bearhound: d.fetch("bearhound"), + cayuga: d.fetch("Cayuga"), + guarneri: d.fetch("guarneri"), + hypochondriacism: d.fetch("hypochondriacism"), + indication: d.fetch("indication"), + jaculative: d.fetch("jaculative"), + nagana: d.fetch("nagana"), + netherlandish: d.fetch("Netherlandish"), + noctivagous: d.fetch("noctivagous"), + nonphysiological: d.fetch("nonphysiological"), + praxis: d.fetch("praxis"), + provision: d.fetch("provision"), + subterhuman: d.fetch("subterhuman"), + sunlit: d.fetch("sunlit"), + syncraniate: d.fetch("syncraniate"), + teachment: d.fetch("teachment"), + unmutinous: d.fetch("unmutinous"), + unstoppable: d.fetch("unstoppable"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class OskarElement < Dry::Struct + attribute :integer_array, Types.Array(Types::Integer).optional + attribute :oskar_class, OskarClass.optional + + def self.from_dynamic!(d) + if schema[:integer_array].right.valid? d + return new(integer_array: d, oskar_class: nil) + end + begin + value = OskarClass.from_dynamic!(d) + if schema[:oskar_class].right.valid? value + return new(oskar_class: value, integer_array: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer_array != nil + integer_array + elsif oskar_class != nil + oskar_class.to_dynamic + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class RebeccaElement < Dry::Struct + attribute :integer, Types::Integer.optional + attribute :rebecca, Rebecca.optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + if schema[:integer].right.valid? d + return new(integer: d, rebecca: nil, string: nil) + end + begin + value = Rebecca.from_dynamic!(d) + if schema[:rebecca].right.valid? value + return new(rebecca: value, integer: nil, string: nil) + end + rescue + end + if schema[:string].right.valid? d + return new(string: d, rebecca: nil, integer: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer != nil + integer + elsif rebecca != nil + rebecca.to_dynamic + elsif string != nil + string + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Rhomboganoidei < Dry::Struct + attribute :integer_array, Types.Array(Types::Integer).optional + attribute :rebecca, Rebecca.optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + if schema[:integer_array].right.valid? d + return new(integer_array: d, rebecca: nil, string: nil) + end + begin + value = Rebecca.from_dynamic!(d) + if schema[:rebecca].right.valid? value + return new(rebecca: value, integer_array: nil, string: nil) + end + rescue + end + if schema[:string].right.valid? d + return new(string: d, integer_array: nil, rebecca: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer_array != nil + integer_array + elsif rebecca != nil + rebecca.to_dynamic + elsif string != nil + string + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Ruellia < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :rebecca, Rebecca.optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, rebecca: nil, string: nil) + end + begin + value = Rebecca.from_dynamic!(d) + if schema[:rebecca].right.valid? value + return new(rebecca: value, bool: nil, string: nil) + end + rescue + end + if schema[:string].right.valid? d + return new(string: d, bool: nil, rebecca: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif rebecca != nil + rebecca.to_dynamic + elsif string != nil + string + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class School < Dry::Struct + attribute :integer, Types::Integer.optional + attribute :integer_map, Types::Hash.meta(of: Types::Integer).optional + attribute :null, Types::Nil.optional + + def self.from_dynamic!(d) + if schema[:integer].right.valid? d + return new(integer: d, integer_map: nil, null: nil) + end + begin + value = Types::Hash[d].map { |k, v| [k, Types::Integer[v]] }.to_h + if schema[:integer_map].right.valid? value + return new(integer_map: value, integer: nil, null: nil) + end + rescue + end + if schema[:null].right.valid? d + return new(null: d, integer: nil, integer_map: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer != nil + integer + elsif integer_map != nil + integer_map + else + nil + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Shakespearolater < Dry::Struct + attribute :double, Types::Double.optional + attribute :integer_array, Types.Array(Types::Integer).optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, integer_array: nil, string: nil) + end + if schema[:integer_array].right.valid? d + return new(integer_array: d, double: nil, string: nil) + end + if schema[:string].right.valid? d + return new(string: d, integer_array: nil, double: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif integer_array != nil + integer_array + elsif string != nil + string + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class TopLevel < Dry::Struct + attribute :abranchiata, Types.Array(Types.Instance(Abranchiata)) + attribute :academe, Types.Array(Types.Instance(Academe)) + attribute :acquirable, Types.Array(Types.Instance(Acquirable)) + attribute :aerometry, Types.Array(Types.Instance(Aerometry)) + attribute :alexin, Types.Array(Types.Instance(Alexin)) + attribute :alleviate, Types.Array(Types.Instance(AlleviateElement)) + attribute :amaas, Types.Array(Types.Instance(Amaa)) + attribute :ambassage, Types.Array(Types.Instance(Ambassage)) + attribute :amphithyron, Types.Array(Amphithyron.optional) + attribute :andriana, Types.Array(Types::String.optional) + attribute :ankee, Types.Array(Types.Instance(AnkeeElement)) + attribute :annihilator, Types.Array(Types::Hash.meta(of: Types::Integer.optional).optional) + attribute :annulose, Types::Nil + attribute :ansarie, Types.Array(Types.Instance(AnsarieElement)) + attribute :aphasia, Types.Array(Types.Instance(Aphasia)) + attribute :asprawl, Types.Array(Types.Instance(Asprawl)) + attribute :attractive, Types.Array(Types::Bool.optional) + attribute :barksome, Types::Hash.meta(of: Types::Integer) + attribute :bedesman, Types.Array(Types.Instance(Bedesman)) + attribute :belard, Types.Array(Types.Instance(Belard)) + attribute :bocking, Types.Array(Types.Instance(Bocking)) + attribute :brawlingly, Types.Array(Types.Instance(Brawlingly)) + attribute :brookie, Types.Array(Types.Instance(Brookie)) + attribute :bumboatman, Types.Array(Types.Instance(Bumboatman)) + attribute :bystreet, Types.Array(Types::Nil) + attribute :calaverite, Types.Array(Types.Instance(Calaverite)) + attribute :catallactic, Types.Array(Types.Instance(Catallactic)) + attribute :cemental, Types.Array(Types.Instance(Cemental)) + attribute :chytridiaceae, Types.Array(Types.Instance(ChytridiaceaeElement)) + attribute :discordia, Types.Array(Types.Instance(DiscordiaElement)) + attribute :endomyces, Types.Array(Types.Instance(Endomyce)) + attribute :epinephelidae, Types.Array(Types.Instance(Epinephelidae)) + attribute :eupatorium, Types.Array(Types.Instance(Eupatorium)) + attribute :gryphosaurus, Types.Array(Types.Instance(GryphosaurusElement)) + attribute :koryak, Types.Array(Types.Instance(Koryak)) + attribute :lavinia, Types.Array(Types.Instance(LaviniaElement)) + attribute :oskar, Types.Array(Types.Instance(OskarElement)) + attribute :rebecca, Types.Array(Types.Instance(RebeccaElement)) + attribute :rhomboganoidei, Types.Array(Types.Instance(Rhomboganoidei)) + attribute :rigsmal, Types::Bool + attribute :ruellia, Types.Array(Types.Instance(Ruellia)) + attribute :school, Types.Array(Types.Instance(School)) + attribute :shakespearolater, Types.Array(Types.Instance(Shakespearolater)) + attribute :svan, Types.Array(Types::Double) + attribute :wayao, Types::Hash.meta(of: Types::Double) + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + abranchiata: d.fetch("Abranchiata").map { |x| Abranchiata.from_dynamic!(x) }, + academe: d.fetch("academe").map { |x| Academe.from_dynamic!(x) }, + acquirable: d.fetch("acquirable").map { |x| Acquirable.from_dynamic!(x) }, + aerometry: d.fetch("aerometry").map { |x| Aerometry.from_dynamic!(x) }, + alexin: d.fetch("alexin").map { |x| Alexin.from_dynamic!(x) }, + alleviate: d.fetch("alleviate").map { |x| AlleviateElement.from_dynamic!(x) }, + amaas: d.fetch("amaas").map { |x| Amaa.from_dynamic!(x) }, + ambassage: d.fetch("ambassage").map { |x| Ambassage.from_dynamic!(x) }, + amphithyron: d.fetch("amphithyron").map { |x| x ? Amphithyron.from_dynamic!(x) : nil }, + andriana: d.fetch("Andriana"), + ankee: d.fetch("ankee").map { |x| AnkeeElement.from_dynamic!(x) }, + annihilator: d.fetch("annihilator").map { |x| Types::Hash.optional[x]&.map { |k, v| [k, v] }&.to_h }, + annulose: d.fetch("annulose"), + ansarie: d.fetch("Ansarie").map { |x| AnsarieElement.from_dynamic!(x) }, + aphasia: d.fetch("aphasia").map { |x| Aphasia.from_dynamic!(x) }, + asprawl: d.fetch("asprawl").map { |x| Asprawl.from_dynamic!(x) }, + attractive: d.fetch("attractive"), + barksome: Types::Hash[d.fetch("barksome")].map { |k, v| [k, Types::Integer[v]] }.to_h, + bedesman: d.fetch("bedesman").map { |x| Bedesman.from_dynamic!(x) }, + belard: d.fetch("belard").map { |x| Belard.from_dynamic!(x) }, + bocking: d.fetch("bocking").map { |x| Bocking.from_dynamic!(x) }, + brawlingly: d.fetch("brawlingly").map { |x| Brawlingly.from_dynamic!(x) }, + brookie: d.fetch("brookie").map { |x| Brookie.from_dynamic!(x) }, + bumboatman: d.fetch("bumboatman").map { |x| Bumboatman.from_dynamic!(x) }, + bystreet: d.fetch("bystreet"), + calaverite: d.fetch("calaverite").map { |x| Calaverite.from_dynamic!(x) }, + catallactic: d.fetch("catallactic").map { |x| Catallactic.from_dynamic!(x) }, + cemental: d.fetch("cemental").map { |x| Cemental.from_dynamic!(x) }, + chytridiaceae: d.fetch("Chytridiaceae").map { |x| ChytridiaceaeElement.from_dynamic!(x) }, + discordia: d.fetch("Discordia").map { |x| DiscordiaElement.from_dynamic!(x) }, + endomyces: d.fetch("Endomyces").map { |x| Endomyce.from_dynamic!(x) }, + epinephelidae: d.fetch("Epinephelidae").map { |x| Epinephelidae.from_dynamic!(x) }, + eupatorium: d.fetch("Eupatorium").map { |x| Eupatorium.from_dynamic!(x) }, + gryphosaurus: d.fetch("Gryphosaurus").map { |x| GryphosaurusElement.from_dynamic!(x) }, + koryak: d.fetch("Koryak").map { |x| Koryak.from_dynamic!(x) }, + lavinia: d.fetch("Lavinia").map { |x| LaviniaElement.from_dynamic!(x) }, + oskar: d.fetch("Oskar").map { |x| OskarElement.from_dynamic!(x) }, + rebecca: d.fetch("Rebecca").map { |x| RebeccaElement.from_dynamic!(x) }, + rhomboganoidei: d.fetch("Rhomboganoidei").map { |x| Rhomboganoidei.from_dynamic!(x) }, + rigsmal: d.fetch("Rigsmal"), + ruellia: d.fetch("Ruellia").map { |x| Ruellia.from_dynamic!(x) }, + school: d.fetch("School").map { |x| School.from_dynamic!(x) }, + shakespearolater: d.fetch("Shakespearolater").map { |x| Shakespearolater.from_dynamic!(x) }, + svan: d.fetch("Svan"), + wayao: Types::Hash[d.fetch("Wayao")].map { |k, v| [k, Types::Double[v]] }.to_h, + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "Abranchiata" => abranchiata.map { |x| x.to_dynamic }, + "academe" => academe.map { |x| x.to_dynamic }, + "acquirable" => acquirable.map { |x| x.to_dynamic }, + "aerometry" => aerometry.map { |x| x.to_dynamic }, + "alexin" => alexin.map { |x| x.to_dynamic }, + "alleviate" => alleviate.map { |x| x.to_dynamic }, + "amaas" => amaas.map { |x| x.to_dynamic }, + "ambassage" => ambassage.map { |x| x.to_dynamic }, + "amphithyron" => amphithyron.map { |x| x&.to_dynamic }, + "Andriana" => andriana, + "ankee" => ankee.map { |x| x.to_dynamic }, + "annihilator" => annihilator, + "annulose" => annulose, + "Ansarie" => ansarie.map { |x| x.to_dynamic }, + "aphasia" => aphasia.map { |x| x.to_dynamic }, + "asprawl" => asprawl.map { |x| x.to_dynamic }, + "attractive" => attractive, + "barksome" => barksome, + "bedesman" => bedesman.map { |x| x.to_dynamic }, + "belard" => belard.map { |x| x.to_dynamic }, + "bocking" => bocking.map { |x| x.to_dynamic }, + "brawlingly" => brawlingly.map { |x| x.to_dynamic }, + "brookie" => brookie.map { |x| x.to_dynamic }, + "bumboatman" => bumboatman.map { |x| x.to_dynamic }, + "bystreet" => bystreet, + "calaverite" => calaverite.map { |x| x.to_dynamic }, + "catallactic" => catallactic.map { |x| x.to_dynamic }, + "cemental" => cemental.map { |x| x.to_dynamic }, + "Chytridiaceae" => chytridiaceae.map { |x| x.to_dynamic }, + "Discordia" => discordia.map { |x| x.to_dynamic }, + "Endomyces" => endomyces.map { |x| x.to_dynamic }, + "Epinephelidae" => epinephelidae.map { |x| x.to_dynamic }, + "Eupatorium" => eupatorium.map { |x| x.to_dynamic }, + "Gryphosaurus" => gryphosaurus.map { |x| x.to_dynamic }, + "Koryak" => koryak.map { |x| x.to_dynamic }, + "Lavinia" => lavinia.map { |x| x.to_dynamic }, + "Oskar" => oskar.map { |x| x.to_dynamic }, + "Rebecca" => rebecca.map { |x| x.to_dynamic }, + "Rhomboganoidei" => rhomboganoidei.map { |x| x.to_dynamic }, + "Rigsmal" => rigsmal, + "Ruellia" => ruellia.map { |x| x.to_dynamic }, + "School" => school.map { |x| x.to_dynamic }, + "Shakespearolater" => shakespearolater.map { |x| x.to_dynamic }, + "Svan" => svan, + "Wayao" => wayao, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end diff --git a/head/ruby/test/inputs/json/priority/combinations3.json/default/TopLevel.rb b/head/ruby/test/inputs/json/priority/combinations3.json/default/TopLevel.rb new file mode 100644 index 0000000..ed482ab --- /dev/null +++ b/head/ruby/test/inputs/json/priority/combinations3.json/default/TopLevel.rb @@ -0,0 +1,2662 @@ +# This code may look unusually verbose for Ruby (and it is), but +# it performs some subtle and complex validation of JSON data. +# +# To parse this JSON, add 'dry-struct' and 'dry-types' gems, then do: +# +# top_level = TopLevel.from_json! "{…}" +# puts top_level.protext.first +# +# If from_json! succeeds, the value returned matches the schema. + +require 'json' +require 'dry-types' +require 'dry-struct' + +module Types + include Dry.Types(default: :nominal) + + Integer = Strict::Integer + Nil = Strict::Nil + Bool = Strict::Bool + Hash = Strict::Hash + String = Strict::String + Double = Strict::Float | Strict::Integer +end + +class JurorClass < Dry::Struct + attribute :adipsy, Types::Nil + attribute :auxiliator, Types::Nil + attribute :benda, Types::Nil + attribute :benjamin, Types::Nil + attribute :brandling, Types::Nil + attribute :epicurishly, Types::Nil + attribute :eremochaetous, Types::Nil + attribute :marten, Types::Nil + attribute :monocline, Types::Nil + attribute :olea, Types::Nil + attribute :palgat, Types::Nil + attribute :pennyworth, Types::Nil + attribute :pioury, Types::Nil + attribute :pragmatistic, Types::Nil + attribute :stylelessness, Types::Nil + attribute :systematical, Types::Nil + attribute :thready, Types::Nil + attribute :uncontemporary, Types::Nil + attribute :uncouched, Types::Nil + attribute :uninhabitedness, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + adipsy: d.fetch("adipsy"), + auxiliator: d.fetch("auxiliator"), + benda: d.fetch("benda"), + benjamin: d.fetch("benjamin"), + brandling: d.fetch("brandling"), + epicurishly: d.fetch("epicurishly"), + eremochaetous: d.fetch("eremochaetous"), + marten: d.fetch("marten"), + monocline: d.fetch("monocline"), + olea: d.fetch("Olea"), + palgat: d.fetch("palgat"), + pennyworth: d.fetch("pennyworth"), + pioury: d.fetch("pioury"), + pragmatistic: d.fetch("pragmatistic"), + stylelessness: d.fetch("stylelessness"), + systematical: d.fetch("systematical"), + thready: d.fetch("thready"), + uncontemporary: d.fetch("uncontemporary"), + uncouched: d.fetch("uncouched"), + uninhabitedness: d.fetch("uninhabitedness"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class JurorElement < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :juror_class, JurorClass.optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, juror_class: nil) + end + begin + value = JurorClass.from_dynamic!(d) + if schema[:juror_class].right.valid? value + return new(juror_class: value, bool: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif juror_class != nil + juror_class.to_dynamic + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Kongoni < Dry::Struct + attribute :integer_array, Types.Array(Types::Integer).optional + attribute :integer_map, Types::Hash.meta(of: Types::Integer).optional + + def self.from_dynamic!(d) + if schema[:integer_array].right.valid? d + return new(integer_array: d, integer_map: nil) + end + begin + value = Types::Hash[d].map { |k, v| [k, Types::Integer[v]] }.to_h + if schema[:integer_map].right.valid? value + return new(integer_map: value, integer_array: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer_array != nil + integer_array + elsif integer_map != nil + integer_map + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class LadronismClass < Dry::Struct + attribute :acclaimer, Types::Nil + attribute :achree, Types::Nil + attribute :base, Types::Nil + attribute :conundrumize, Types::Nil + attribute :degerminator, Types::Nil + attribute :describable, Types::Nil + attribute :exasperatedly, Types::Nil + attribute :heroine, Types::Nil + attribute :indazin, Types::Nil + attribute :luteous, Types::Nil + attribute :papular, Types::Nil + attribute :pritch, Types::Nil + attribute :prodenia, Types::Nil + attribute :seege, Types::Nil + attribute :shopgirl, Types::Nil + attribute :tragedietta, Types::Nil + attribute :unsparse, Types::Nil + attribute :uplook, Types::Nil + attribute :vermiformis, Types::Nil + attribute :whafabout, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + acclaimer: d.fetch("acclaimer"), + achree: d.fetch("achree"), + base: d.fetch("base"), + conundrumize: d.fetch("conundrumize"), + degerminator: d.fetch("degerminator"), + describable: d.fetch("describable"), + exasperatedly: d.fetch("exasperatedly"), + heroine: d.fetch("heroine"), + indazin: d.fetch("indazin"), + luteous: d.fetch("luteous"), + papular: d.fetch("papular"), + pritch: d.fetch("pritch"), + prodenia: d.fetch("Prodenia"), + seege: d.fetch("seege"), + shopgirl: d.fetch("shopgirl"), + tragedietta: d.fetch("tragedietta"), + unsparse: d.fetch("unsparse"), + uplook: d.fetch("uplook"), + vermiformis: d.fetch("vermiformis"), + whafabout: d.fetch("whafabout"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class LadronismElement < Dry::Struct + attribute :double, Types::Double.optional + attribute :ladronism_class, LadronismClass.optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, ladronism_class: nil, string: nil) + end + begin + value = LadronismClass.from_dynamic!(d) + if schema[:ladronism_class].right.valid? value + return new(ladronism_class: value, double: nil, string: nil) + end + rescue + end + if schema[:string].right.valid? d + return new(string: d, ladronism_class: nil, double: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif ladronism_class != nil + ladronism_class.to_dynamic + elsif string != nil + string + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class LandlubberlyClass < Dry::Struct + attribute :acropoleis, Types::Nil + attribute :aminate, Types::Nil + attribute :amyraldism, Types::Nil + attribute :bipenniform, Types::Nil + attribute :bugre, Types::Nil + attribute :calycule, Types::Nil + attribute :caoutchouc, Types::Nil + attribute :disprover, Types::Nil + attribute :fitroot, Types::Nil + attribute :fulgently, Types::Nil + attribute :kickup, Types::Nil + attribute :laevoversion, Types::Nil + attribute :moter, Types::Nil + attribute :objectivity, Types::Nil + attribute :posterity, Types::Nil + attribute :postnuptial, Types::Nil + attribute :precedentary, Types::Nil + attribute :saddling, Types::Nil + attribute :subcurrent, Types::Nil + attribute :unrecriminative, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + acropoleis: d.fetch("acropoleis"), + aminate: d.fetch("aminate"), + amyraldism: d.fetch("Amyraldism"), + bipenniform: d.fetch("bipenniform"), + bugre: d.fetch("bugre"), + calycule: d.fetch("calycule"), + caoutchouc: d.fetch("caoutchouc"), + disprover: d.fetch("disprover"), + fitroot: d.fetch("fitroot"), + fulgently: d.fetch("fulgently"), + kickup: d.fetch("kickup"), + laevoversion: d.fetch("laevoversion"), + moter: d.fetch("moter"), + objectivity: d.fetch("objectivity"), + posterity: d.fetch("posterity"), + postnuptial: d.fetch("postnuptial"), + precedentary: d.fetch("precedentary"), + saddling: d.fetch("saddling"), + subcurrent: d.fetch("subcurrent"), + unrecriminative: d.fetch("unrecriminative"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class LandlubberlyElement < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :integer, Types::Integer.optional + attribute :landlubberly_class, LandlubberlyClass.optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, landlubberly_class: nil, integer: nil) + end + if schema[:integer].right.valid? d + return new(integer: d, bool: nil, landlubberly_class: nil) + end + begin + value = LandlubberlyClass.from_dynamic!(d) + if schema[:landlubberly_class].right.valid? value + return new(landlubberly_class: value, bool: nil, integer: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif integer != nil + integer + elsif landlubberly_class != nil + landlubberly_class.to_dynamic + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Listener < Dry::Struct + attribute :integer, Types::Integer.optional + attribute :null_array, Types.Array(Types::Nil).optional + + def self.from_dynamic!(d) + if schema[:integer].right.valid? d + return new(integer: d, null_array: nil) + end + if schema[:null_array].right.valid? d + return new(null_array: d, integer: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer != nil + integer + elsif null_array != nil + null_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class LupusClass < Dry::Struct + attribute :catharticalness, Types::Double.optional + attribute :chirotherium, Types::Integer.optional + attribute :chlorioninae, Types::Integer.optional + attribute :corvinae, Types::Integer.optional + attribute :crassina, Types::Integer.optional + attribute :disdiapason, Types::String.optional + attribute :exiguity, Types::Integer.optional + attribute :farcist, Types::Integer.optional + attribute :holographical, Types::Integer.optional + attribute :homocerc, Types::Bool.optional + attribute :ichthyophagan, Types::Integer.optional + attribute :implacable, Types::Integer.optional + attribute :nonbookish, Types::Nil.optional + attribute :outshiner, Types::Integer.optional + attribute :overweather, Types::Integer.optional + attribute :protonegroid, Types::Integer.optional + attribute :shallowish, Types::Integer.optional + attribute :snoke, Types::Integer.optional + attribute :snout, Types::Integer.optional + attribute :surveillance, Types::Integer.optional + attribute :threshingtime, Types::Integer.optional + attribute :thysanocarpus, Types::Integer.optional + attribute :unsignificantly, Types::Integer.optional + attribute :unsnap, Types::Integer.optional + attribute :vendible, Types::Integer.optional + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + catharticalness: d["catharticalness"], + chirotherium: d["Chirotherium"], + chlorioninae: d["Chlorioninae"], + corvinae: d["Corvinae"], + crassina: d["Crassina"], + disdiapason: d["disdiapason"], + exiguity: d["exiguity"], + farcist: d["farcist"], + holographical: d["holographical"], + homocerc: d["homocerc"], + ichthyophagan: d["ichthyophagan"], + implacable: d["implacable"], + nonbookish: d["nonbookish"], + outshiner: d["outshiner"], + overweather: d["overweather"], + protonegroid: d["protonegroid"], + shallowish: d["shallowish"], + snoke: d["snoke"], + snout: d["snout"], + surveillance: d["surveillance"], + threshingtime: d["threshingtime"], + thysanocarpus: d["Thysanocarpus"], + unsignificantly: d["unsignificantly"], + unsnap: d["unsnap"], + vendible: d["vendible"], + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class LupusElement < Dry::Struct + attribute :integer, Types::Integer.optional + attribute :lupus_class, LupusClass.optional + + def self.from_dynamic!(d) + if schema[:integer].right.valid? d + return new(integer: d, lupus_class: nil) + end + begin + value = LupusClass.from_dynamic!(d) + if schema[:lupus_class].right.valid? value + return new(lupus_class: value, integer: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer != nil + integer + elsif lupus_class != nil + lupus_class.to_dynamic + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Maslin < Dry::Struct + attribute :alicant, Types::Integer.optional + attribute :antiatonement, Types::Nil.optional + attribute :anticorrosive, Types::Integer.optional + attribute :aphidozer, Types::Nil.optional + attribute :bakuninist, Types::Nil.optional + attribute :be, Types::Integer.optional + attribute :catharticalness, Types::Double.optional + attribute :chirotherium, Types::Integer.optional + attribute :chub, Types::Integer.optional + attribute :cuprosilicon, Types::Integer.optional + attribute :curtailedly, Types::Integer.optional + attribute :dellenite, Types::Integer.optional + attribute :dimitry, Types::Integer.optional + attribute :disdiapason, Types::String.optional + attribute :edifying, Types::Nil.optional + attribute :ethmoiditis, Types::Integer.optional + attribute :gastralgy, Types::Nil.optional + attribute :goatherd, Types::Integer.optional + attribute :hammerdress, Types::Integer.optional + attribute :hangfire, Types::Nil.optional + attribute :homocerc, Types::Bool.optional + attribute :lacunosity, Types::Integer.optional + attribute :longiloquence, Types::Nil.optional + attribute :mameliere, Types::Integer.optional + attribute :motherless, Types::Nil.optional + attribute :nonbookish, Types::Nil.optional + attribute :noncorrodible, Types::Nil.optional + attribute :nonsensicality, Types::Nil.optional + attribute :oafishly, Types::Integer.optional + attribute :pfund, Types::Nil.optional + attribute :preadvisory, Types::Nil.optional + attribute :retroflexed, Types::Nil.optional + attribute :saccharulmic, Types::Integer.optional + attribute :scowlful, Types::Integer.optional + attribute :secluded, Types::Nil.optional + attribute :slackage, Types::Nil.optional + attribute :sphaeridial, Types::Integer.optional + attribute :spondulics, Types::Nil.optional + attribute :subsecive, Types::Integer.optional + attribute :swellmobsman, Types::Nil.optional + attribute :trachyglossate, Types::Integer.optional + attribute :trialogue, Types::Nil.optional + attribute :unassuaged, Types::Integer.optional + attribute :ungross, Types::Nil.optional + attribute :unjudiciously, Types::Nil.optional + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + alicant: d["Alicant"], + antiatonement: d["antiatonement"], + anticorrosive: d["anticorrosive"], + aphidozer: d["aphidozer"], + bakuninist: d["Bakuninist"], + be: d["be"], + catharticalness: d["catharticalness"], + chirotherium: d["Chirotherium"], + chub: d["chub"], + cuprosilicon: d["cuprosilicon"], + curtailedly: d["curtailedly"], + dellenite: d["dellenite"], + dimitry: d["Dimitry"], + disdiapason: d["disdiapason"], + edifying: d["edifying"], + ethmoiditis: d["ethmoiditis"], + gastralgy: d["gastralgy"], + goatherd: d["goatherd"], + hammerdress: d["hammerdress"], + hangfire: d["hangfire"], + homocerc: d["homocerc"], + lacunosity: d["lacunosity"], + longiloquence: d["longiloquence"], + mameliere: d["mameliere"], + motherless: d["motherless"], + nonbookish: d["nonbookish"], + noncorrodible: d["noncorrodible"], + nonsensicality: d["nonsensicality"], + oafishly: d["oafishly"], + pfund: d["pfund"], + preadvisory: d["preadvisory"], + retroflexed: d["retroflexed"], + saccharulmic: d["saccharulmic"], + scowlful: d["scowlful"], + secluded: d["secluded"], + slackage: d["slackage"], + sphaeridial: d["sphaeridial"], + spondulics: d["spondulics"], + subsecive: d["subsecive"], + swellmobsman: d["swellmobsman"], + trachyglossate: d["trachyglossate"], + trialogue: d["trialogue"], + unassuaged: d["unassuaged"], + ungross: d["ungross"], + unjudiciously: d["unjudiciously"], + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class MonaziteClass < Dry::Struct + attribute :catharticalness, Types::Double + attribute :chirotherium, Types::Integer + attribute :disdiapason, Types::String + attribute :homocerc, Types::Bool + attribute :nonbookish, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + catharticalness: d.fetch("catharticalness"), + chirotherium: d.fetch("Chirotherium"), + disdiapason: d.fetch("disdiapason"), + homocerc: d.fetch("homocerc"), + nonbookish: d.fetch("nonbookish"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "catharticalness" => catharticalness, + "Chirotherium" => chirotherium, + "disdiapason" => disdiapason, + "homocerc" => homocerc, + "nonbookish" => nonbookish, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class MonaziteElement < Dry::Struct + attribute :double, Types::Double.optional + attribute :monazite_class, MonaziteClass.optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, monazite_class: nil) + end + begin + value = MonaziteClass.from_dynamic!(d) + if schema[:monazite_class].right.valid? value + return new(monazite_class: value, double: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif monazite_class != nil + monazite_class.to_dynamic + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Monoliteral < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :null_array, Types.Array(Types::Nil).optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, null_array: nil) + end + if schema[:null_array].right.valid? d + return new(null_array: d, bool: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif null_array != nil + null_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class MonotheisticallyClass < Dry::Struct + attribute :blaspheme, Types::Nil.optional + attribute :catharticalness, Types::Double.optional + attribute :celiosalpingectomy, Types::Nil.optional + attribute :chirotherium, Types::Integer.optional + attribute :consummativeness, Types::Nil.optional + attribute :disdiapason, Types::String.optional + attribute :egestive, Types::Nil.optional + attribute :enchylema, Types::Nil.optional + attribute :gasconade, Types::Nil.optional + attribute :holidayer, Types::Nil.optional + attribute :homocerc, Types::Bool.optional + attribute :intuitionalism, Types::Nil.optional + attribute :lophiostomate, Types::Nil.optional + attribute :monotheistically_trust, Types::Nil.optional + attribute :nonbookish, Types::Nil.optional + attribute :nonvolition, Types::Nil.optional + attribute :palatableness, Types::Nil.optional + attribute :pimpery, Types::Nil.optional + attribute :previolation, Types::Nil.optional + attribute :reconveyance, Types::Nil.optional + attribute :registership, Types::Nil.optional + attribute :rhyacolite, Types::Nil.optional + attribute :smithereens, Types::Nil.optional + attribute :superedification, Types::Nil.optional + attribute :whitestone, Types::Nil.optional + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + blaspheme: d["blaspheme"], + catharticalness: d["catharticalness"], + celiosalpingectomy: d["celiosalpingectomy"], + chirotherium: d["Chirotherium"], + consummativeness: d["consummativeness"], + disdiapason: d["disdiapason"], + egestive: d["egestive"], + enchylema: d["enchylema"], + gasconade: d["gasconade"], + holidayer: d["holidayer"], + homocerc: d["homocerc"], + intuitionalism: d["intuitionalism"], + lophiostomate: d["lophiostomate"], + monotheistically_trust: d["trust"], + nonbookish: d["nonbookish"], + nonvolition: d["nonvolition"], + palatableness: d["palatableness"], + pimpery: d["pimpery"], + previolation: d["previolation"], + reconveyance: d["reconveyance"], + registership: d["registership"], + rhyacolite: d["rhyacolite"], + smithereens: d["smithereens"], + superedification: d["superedification"], + whitestone: d["whitestone"], + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + "trust" => monotheistically_trust, + "nonbookish" => nonbookish, + "nonvolition" => nonvolition, + "palatableness" => palatableness, + "pimpery" => pimpery, + "previolation" => previolation, + "reconveyance" => reconveyance, + "registership" => registership, + "rhyacolite" => rhyacolite, + "smithereens" => smithereens, + "superedification" => superedification, + "whitestone" => whitestone, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class MonotheisticallyElement < Dry::Struct + attribute :monotheistically_class, MonotheisticallyClass.optional + attribute :null_array, Types.Array(Types::Nil).optional + + def self.from_dynamic!(d) + begin + value = MonotheisticallyClass.from_dynamic!(d) + if schema[:monotheistically_class].right.valid? value + return new(monotheistically_class: value, null_array: nil) + end + rescue + end + if schema[:null_array].right.valid? d + return new(null_array: d, monotheistically_class: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if monotheistically_class != nil + monotheistically_class.to_dynamic + elsif null_array != nil + null_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Montage < Dry::Struct + attribute :double, Types::Double.optional + attribute :null_array, Types.Array(Types::Nil).optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, null_array: nil, string: nil) + end + if schema[:null_array].right.valid? d + return new(null_array: d, double: nil, string: nil) + end + if schema[:string].right.valid? d + return new(string: d, null_array: nil, double: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif null_array != nil + null_array + elsif string != nil + string + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Moralness < Dry::Struct + attribute :double, Types::Double.optional + attribute :null, Types::Nil.optional + attribute :null_array, Types.Array(Types::Nil).optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, null_array: nil, null: nil) + end + if schema[:null].right.valid? d + return new(null: d, null_array: nil, double: nil) + end + if schema[:null_array].right.valid? d + return new(null_array: d, double: nil, null: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif null_array != nil + null_array + else + nil + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Mulishly < Dry::Struct + attribute :double, Types::Double.optional + attribute :integer_array, Types.Array(Types::Integer).optional + attribute :null, Types::Nil.optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, integer_array: nil, null: nil) + end + if schema[:integer_array].right.valid? d + return new(integer_array: d, double: nil, null: nil) + end + if schema[:null].right.valid? d + return new(null: d, integer_array: nil, double: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif integer_array != nil + integer_array + else + nil + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Myoscope < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :integer, Types::Integer.optional + attribute :null_array, Types.Array(Types::Nil).optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, null_array: nil, integer: nil) + end + if schema[:integer].right.valid? d + return new(integer: d, null_array: nil, bool: nil) + end + if schema[:null_array].right.valid? d + return new(null_array: d, bool: nil, integer: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif integer != nil + integer + elsif null_array != nil + null_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Neuromastic < Dry::Struct + attribute :double, Types::Double.optional + attribute :null_array, Types.Array(Types::Nil).optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, null_array: nil) + end + if schema[:null_array].right.valid? d + return new(null_array: d, double: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif null_array != nil + null_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Noncontributing < Dry::Struct + attribute :estevin, Types::String + attribute :jolterhead, Types::Double + attribute :sauternes, Types::Integer + attribute :sparsely, Types::Bool + attribute :unrequested, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + estevin: d.fetch("estevin"), + jolterhead: d.fetch("jolterhead"), + sauternes: d.fetch("sauternes"), + sparsely: d.fetch("sparsely"), + unrequested: d.fetch("unrequested"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "estevin" => estevin, + "jolterhead" => jolterhead, + "sauternes" => sauternes, + "sparsely" => sparsely, + "unrequested" => unrequested, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Nonnervous < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :integer, Types::Integer.optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, integer: nil) + end + if schema[:integer].right.valid? d + return new(integer: d, bool: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif integer != nil + integer + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Nonvaluation < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :double, Types::Double.optional + attribute :null_array, Types.Array(Types::Nil).optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, null_array: nil, double: nil) + end + if schema[:double].right.valid? d + return new(double: d, null_array: nil, bool: nil) + end + if schema[:null_array].right.valid? d + return new(null_array: d, bool: nil, double: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif double != nil + double + elsif null_array != nil + null_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class OccupationalistClass < Dry::Struct + attribute :beholdable, Types::Nil + attribute :brotuliform, Types::Nil + attribute :chimakum, Types::Nil + attribute :doodler, Types::Nil + attribute :emulsin, Types::Nil + attribute :fin, Types::Nil + attribute :flourishing, Types::Nil + attribute :flueless, Types::Nil + attribute :furtively, Types::Nil + attribute :gritter, Types::Nil + attribute :interwish, Types::Nil + attribute :monoxylic, Types::Nil + attribute :myristic, Types::Nil + attribute :nightwear, Types::Nil + attribute :peruser, Types::Nil + attribute :theoastrological, Types::Nil + attribute :thumby, Types::Nil + attribute :tingitid, Types::Nil + attribute :trailless, Types::Nil + attribute :unpocketed, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + beholdable: d.fetch("beholdable"), + brotuliform: d.fetch("brotuliform"), + chimakum: d.fetch("Chimakum"), + doodler: d.fetch("doodler"), + emulsin: d.fetch("emulsin"), + fin: d.fetch("Fin"), + flourishing: d.fetch("flourishing"), + flueless: d.fetch("flueless"), + furtively: d.fetch("furtively"), + gritter: d.fetch("gritter"), + interwish: d.fetch("interwish"), + monoxylic: d.fetch("monoxylic"), + myristic: d.fetch("myristic"), + nightwear: d.fetch("nightwear"), + peruser: d.fetch("peruser"), + theoastrological: d.fetch("theoastrological"), + thumby: d.fetch("thumby"), + tingitid: d.fetch("tingitid"), + trailless: d.fetch("trailless"), + unpocketed: d.fetch("unpocketed"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class OccupationalistElement < Dry::Struct + attribute :null, Types::Nil.optional + attribute :null_array, Types.Array(Types::Nil).optional + attribute :occupationalist_class, OccupationalistClass.optional + + def self.from_dynamic!(d) + if schema[:null].right.valid? d + return new(null: d, null_array: nil, occupationalist_class: nil) + end + if schema[:null_array].right.valid? d + return new(null_array: d, occupationalist_class: nil, null: nil) + end + begin + value = OccupationalistClass.from_dynamic!(d) + if schema[:occupationalist_class].right.valid? value + return new(occupationalist_class: value, null_array: nil, null: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if null_array != nil + null_array + elsif occupationalist_class != nil + occupationalist_class.to_dynamic + else + nil + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class OutrivalClass < Dry::Struct + attribute :adroitly, Types::Nil + attribute :bridehood, Types::Nil + attribute :castoroides, Types::Nil + attribute :czechoslovak, Types::Nil + attribute :diagenesis, Types::Nil + attribute :dihexahedron, Types::Nil + attribute :dopester, Types::Nil + attribute :eumerism, Types::Nil + attribute :flyness, Types::Nil + attribute :fouler, Types::Nil + attribute :laudanosine, Types::Nil + attribute :lingulidae, Types::Nil + attribute :minutary, Types::Nil + attribute :mitra, Types::Nil + attribute :opisthorchiasis, Types::Nil + attribute :pensively, Types::Nil + attribute :pubigerous, Types::Nil + attribute :rebellious, Types::Nil + attribute :recodify, Types::Nil + attribute :unpaced, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + adroitly: d.fetch("adroitly"), + bridehood: d.fetch("bridehood"), + castoroides: d.fetch("Castoroides"), + czechoslovak: d.fetch("Czechoslovak"), + diagenesis: d.fetch("diagenesis"), + dihexahedron: d.fetch("dihexahedron"), + dopester: d.fetch("dopester"), + eumerism: d.fetch("eumerism"), + flyness: d.fetch("flyness"), + fouler: d.fetch("fouler"), + laudanosine: d.fetch("laudanosine"), + lingulidae: d.fetch("Lingulidae"), + minutary: d.fetch("minutary"), + mitra: d.fetch("mitra"), + opisthorchiasis: d.fetch("opisthorchiasis"), + pensively: d.fetch("pensively"), + pubigerous: d.fetch("pubigerous"), + rebellious: d.fetch("rebellious"), + recodify: d.fetch("recodify"), + unpaced: d.fetch("unpaced"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class OutrivalElement < Dry::Struct + attribute :double, Types::Double.optional + attribute :null, Types::Nil.optional + attribute :outrival_class, OutrivalClass.optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, outrival_class: nil, null: nil) + end + if schema[:null].right.valid? d + return new(null: d, outrival_class: nil, double: nil) + end + begin + value = OutrivalClass.from_dynamic!(d) + if schema[:outrival_class].right.valid? value + return new(outrival_class: value, double: nil, null: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif outrival_class != nil + outrival_class.to_dynamic + else + nil + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Paleographically < Dry::Struct + attribute :double, Types::Double.optional + attribute :union_map, Types::Hash.meta(of: Types::Integer.optional).optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, union_map: nil) + end + begin + value = Types::Hash[d].map { |k, v| [k, v] }.to_h + if schema[:union_map].right.valid? value + return new(union_map: value, double: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif union_map != nil + union_map + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Pamphletwise < Dry::Struct + attribute :integer, Types::Integer.optional + attribute :integer_map, Types::Hash.meta(of: Types::Integer).optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + if schema[:integer].right.valid? d + return new(integer: d, integer_map: nil, string: nil) + end + begin + value = Types::Hash[d].map { |k, v| [k, Types::Integer[v]] }.to_h + if schema[:integer_map].right.valid? value + return new(integer_map: value, integer: nil, string: nil) + end + rescue + end + if schema[:string].right.valid? d + return new(string: d, integer: nil, integer_map: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer != nil + integer + elsif integer_map != nil + integer_map + elsif string != nil + string + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Pediatric < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :double, Types::Double.optional + attribute :null, Types::Nil.optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, double: nil, null: nil) + end + if schema[:double].right.valid? d + return new(double: d, bool: nil, null: nil) + end + if schema[:null].right.valid? d + return new(null: d, bool: nil, double: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif double != nil + double + else + nil + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class PiaculumClass < Dry::Struct + attribute :alada, Types::Integer.optional + attribute :amphistomous, Types::Integer.optional + attribute :boysenberry, Types::Integer.optional + attribute :catharticalness, Types::Double.optional + attribute :chirotherium, Types::Integer.optional + attribute :decardinalize, Types::Integer.optional + attribute :discouragement, Types::Integer.optional + attribute :disdiapason, Types::String.optional + attribute :doitrified, Types::Integer.optional + attribute :hexaspermous, Types::Integer.optional + attribute :homocerc, Types::Bool.optional + attribute :insinking, Types::Integer.optional + attribute :loathfulness, Types::Integer.optional + attribute :miasmatical, Types::Integer.optional + attribute :neurofibril, Types::Integer.optional + attribute :nonbookish, Types::Nil.optional + attribute :phonendoscope, Types::Integer.optional + attribute :pilferment, Types::Integer.optional + attribute :predismissory, Types::Integer.optional + attribute :preinscription, Types::Integer.optional + attribute :quotative, Types::Integer.optional + attribute :sienna, Types::Integer.optional + attribute :thorax, Types::Integer.optional + attribute :yachting, Types::Integer.optional + attribute :zipper, Types::Integer.optional + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + alada: d["alada"], + amphistomous: d["amphistomous"], + boysenberry: d["boysenberry"], + catharticalness: d["catharticalness"], + chirotherium: d["Chirotherium"], + decardinalize: d["decardinalize"], + discouragement: d["discouragement"], + disdiapason: d["disdiapason"], + doitrified: d["doitrified"], + hexaspermous: d["hexaspermous"], + homocerc: d["homocerc"], + insinking: d["insinking"], + loathfulness: d["loathfulness"], + miasmatical: d["miasmatical"], + neurofibril: d["neurofibril"], + nonbookish: d["nonbookish"], + phonendoscope: d["phonendoscope"], + pilferment: d["pilferment"], + predismissory: d["predismissory"], + preinscription: d["preinscription"], + quotative: d["quotative"], + sienna: d["sienna"], + thorax: d["thorax"], + yachting: d["yachting"], + zipper: d["Zipper"], + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class PiaculumElement < Dry::Struct + attribute :double, Types::Double.optional + attribute :piaculum_class, PiaculumClass.optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, piaculum_class: nil) + end + begin + value = PiaculumClass.from_dynamic!(d) + if schema[:piaculum_class].right.valid? value + return new(piaculum_class: value, double: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif piaculum_class != nil + piaculum_class.to_dynamic + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Piccadilly < Dry::Struct + attribute :double, Types::Double.optional + attribute :null, Types::Nil.optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, null: nil, string: nil) + end + if schema[:null].right.valid? d + return new(null: d, double: nil, string: nil) + end + if schema[:string].right.valid? d + return new(string: d, double: nil, null: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif string != nil + string + else + nil + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Piffler < Dry::Struct + attribute :monazite_class, MonaziteClass.optional + attribute :null_array, Types.Array(Types::Nil).optional + + def self.from_dynamic!(d) + begin + value = MonaziteClass.from_dynamic!(d) + if schema[:monazite_class].right.valid? value + return new(monazite_class: value, null_array: nil) + end + rescue + end + if schema[:null_array].right.valid? d + return new(null_array: d, monazite_class: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if monazite_class != nil + monazite_class.to_dynamic + elsif null_array != nil + null_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Pithful < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :integer, Types::Integer.optional + attribute :null, Types::Nil.optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, integer: nil, null: nil) + end + if schema[:integer].right.valid? d + return new(integer: d, bool: nil, null: nil) + end + if schema[:null].right.valid? d + return new(null: d, bool: nil, integer: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif integer != nil + integer + else + nil + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Placuntiti < Dry::Struct + attribute :integer, Types::Integer.optional + attribute :integer_map, Types::Hash.meta(of: Types::Integer).optional + + def self.from_dynamic!(d) + if schema[:integer].right.valid? d + return new(integer: d, integer_map: nil) + end + begin + value = Types::Hash[d].map { |k, v| [k, Types::Integer[v]] }.to_h + if schema[:integer_map].right.valid? value + return new(integer_map: value, integer: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer != nil + integer + elsif integer_map != nil + integer_map + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Plectopterous < Dry::Struct + attribute :double, Types::Double.optional + attribute :integer_map, Types::Hash.meta(of: Types::Integer).optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, integer_map: nil) + end + begin + value = Types::Hash[d].map { |k, v| [k, Types::Integer[v]] }.to_h + if schema[:integer_map].right.valid? value + return new(integer_map: value, double: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif integer_map != nil + integer_map + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Pneumocele < Dry::Struct + attribute :carbonarism, Types::Nil.optional + attribute :catharticalness, Types::Double.optional + attribute :chirotherium, Types::Integer.optional + attribute :cineolic, Types::Nil.optional + attribute :cobbly, Types::Nil.optional + attribute :conchyliferous, Types::Nil.optional + attribute :congregation, Types::Nil.optional + attribute :disdiapason, Types::String.optional + attribute :enterotomy, Types::Nil.optional + attribute :entophytal, Types::Nil.optional + attribute :fewtrils, Types::Nil.optional + attribute :herem, Types::Nil.optional + attribute :homocerc, Types::Bool.optional + attribute :koniga, Types::Nil.optional + attribute :meticulosity, Types::Nil.optional + attribute :micky, Types::Nil.optional + attribute :mismarriage, Types::Nil.optional + attribute :neurotrophic, Types::Nil.optional + attribute :nonbookish, Types::Nil.optional + attribute :persuasively, Types::Nil.optional + attribute :replaceable, Types::Nil.optional + attribute :silex, Types::Nil.optional + attribute :taillight, Types::Nil.optional + attribute :unjealous, Types::Nil.optional + attribute :visitorial, Types::Nil.optional + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + carbonarism: d["Carbonarism"], + catharticalness: d["catharticalness"], + chirotherium: d["Chirotherium"], + cineolic: d["cineolic"], + cobbly: d["cobbly"], + conchyliferous: d["conchyliferous"], + congregation: d["congregation"], + disdiapason: d["disdiapason"], + enterotomy: d["enterotomy"], + entophytal: d["entophytal"], + fewtrils: d["fewtrils"], + herem: d["herem"], + homocerc: d["homocerc"], + koniga: d["Koniga"], + meticulosity: d["meticulosity"], + micky: d["Micky"], + mismarriage: d["mismarriage"], + neurotrophic: d["neurotrophic"], + nonbookish: d["nonbookish"], + persuasively: d["persuasively"], + replaceable: d["replaceable"], + silex: d["silex"], + taillight: d["taillight"], + unjealous: d["unjealous"], + visitorial: d["visitorial"], + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Poliorcetic < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :monazite_class, MonaziteClass.optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, monazite_class: nil) + end + begin + value = MonaziteClass.from_dynamic!(d) + if schema[:monazite_class].right.valid? value + return new(monazite_class: value, bool: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif monazite_class != nil + monazite_class.to_dynamic + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Poormaster < Dry::Struct + attribute :integer_array, Types.Array(Types::Integer).optional + attribute :integer_map, Types::Hash.meta(of: Types::Integer).optional + attribute :null, Types::Nil.optional + + def self.from_dynamic!(d) + if schema[:integer_array].right.valid? d + return new(integer_array: d, integer_map: nil, null: nil) + end + begin + value = Types::Hash[d].map { |k, v| [k, Types::Integer[v]] }.to_h + if schema[:integer_map].right.valid? value + return new(integer_map: value, integer_array: nil, null: nil) + end + rescue + end + if schema[:null].right.valid? d + return new(null: d, integer_array: nil, integer_map: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer_array != nil + integer_array + elsif integer_map != nil + integer_map + else + nil + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class PotwhiskyClass < Dry::Struct + attribute :arciform, Types::Nil + attribute :cresolin, Types::Nil + attribute :disheartener, Types::Nil + attribute :disproportionable, Types::Nil + attribute :euchorda, Types::Nil + attribute :ferryway, Types::Nil + attribute :filamentiferous, Types::Nil + attribute :flemish, Types::Nil + attribute :forgainst, Types::Nil + attribute :grainering, Types::Nil + attribute :irrevoluble, Types::Nil + attribute :kindredship, Types::Nil + attribute :pinguitudinous, Types::Nil + attribute :simpletonic, Types::Nil + attribute :singsong, Types::Nil + attribute :submergement, Types::Nil + attribute :supraoesophagal, Types::Nil + attribute :thrashel, Types::Nil + attribute :tyremesis, Types::Nil + attribute :yoruba, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + arciform: d.fetch("arciform"), + cresolin: d.fetch("cresolin"), + disheartener: d.fetch("disheartener"), + disproportionable: d.fetch("disproportionable"), + euchorda: d.fetch("Euchorda"), + ferryway: d.fetch("ferryway"), + filamentiferous: d.fetch("filamentiferous"), + flemish: d.fetch("flemish"), + forgainst: d.fetch("forgainst"), + grainering: d.fetch("grainering"), + irrevoluble: d.fetch("irrevoluble"), + kindredship: d.fetch("kindredship"), + pinguitudinous: d.fetch("pinguitudinous"), + simpletonic: d.fetch("simpletonic"), + singsong: d.fetch("singsong"), + submergement: d.fetch("submergement"), + supraoesophagal: d.fetch("supraoesophagal"), + thrashel: d.fetch("thrashel"), + tyremesis: d.fetch("tyremesis"), + yoruba: d.fetch("Yoruba"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class PotwhiskyElement < Dry::Struct + attribute :integer, Types::Integer.optional + attribute :null, Types::Nil.optional + attribute :potwhisky_class, PotwhiskyClass.optional + + def self.from_dynamic!(d) + if schema[:integer].right.valid? d + return new(integer: d, potwhisky_class: nil, null: nil) + end + if schema[:null].right.valid? d + return new(null: d, potwhisky_class: nil, integer: nil) + end + begin + value = PotwhiskyClass.from_dynamic!(d) + if schema[:potwhisky_class].right.valid? value + return new(potwhisky_class: value, integer: nil, null: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer != nil + integer + elsif potwhisky_class != nil + potwhisky_class.to_dynamic + else + nil + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Practicalizer < Dry::Struct + attribute :monazite_class, MonaziteClass.optional + attribute :null_array, Types.Array(Types::Nil).optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + begin + value = MonaziteClass.from_dynamic!(d) + if schema[:monazite_class].right.valid? value + return new(monazite_class: value, null_array: nil, string: nil) + end + rescue + end + if schema[:null_array].right.valid? d + return new(null_array: d, monazite_class: nil, string: nil) + end + if schema[:string].right.valid? d + return new(string: d, null_array: nil, monazite_class: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if monazite_class != nil + monazite_class.to_dynamic + elsif null_array != nil + null_array + elsif string != nil + string + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class PrefreshmanClass < Dry::Struct + attribute :azorubine, Types::Nil + attribute :choroiditis, Types::Nil + attribute :coagulatory, Types::Nil + attribute :cyclorama, Types::Nil + attribute :dolphus, Types::Nil + attribute :duckhearted, Types::Nil + attribute :ficus, Types::Nil + attribute :gemaric, Types::Nil + attribute :jugation, Types::Nil + attribute :myoliposis, Types::Nil + attribute :nonnomination, Types::Nil + attribute :palay, Types::Nil + attribute :pentactinal, Types::Nil + attribute :phaet, Types::Nil + attribute :piquant, Types::Nil + attribute :registration, Types::Nil + attribute :remancipation, Types::Nil + attribute :scutatiform, Types::Nil + attribute :theodolite, Types::Nil + attribute :underward, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + azorubine: d.fetch("azorubine"), + choroiditis: d.fetch("choroiditis"), + coagulatory: d.fetch("coagulatory"), + cyclorama: d.fetch("cyclorama"), + dolphus: d.fetch("Dolphus"), + duckhearted: d.fetch("duckhearted"), + ficus: d.fetch("Ficus"), + gemaric: d.fetch("Gemaric"), + jugation: d.fetch("jugation"), + myoliposis: d.fetch("myoliposis"), + nonnomination: d.fetch("nonnomination"), + palay: d.fetch("palay"), + pentactinal: d.fetch("pentactinal"), + phaet: d.fetch("Phaet"), + piquant: d.fetch("piquant"), + registration: d.fetch("registration"), + remancipation: d.fetch("remancipation"), + scutatiform: d.fetch("scutatiform"), + theodolite: d.fetch("theodolite"), + underward: d.fetch("underward"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class PrefreshmanElement < Dry::Struct + attribute :null_array, Types.Array(Types::Nil).optional + attribute :prefreshman_class, PrefreshmanClass.optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + if schema[:null_array].right.valid? d + return new(null_array: d, prefreshman_class: nil, string: nil) + end + begin + value = PrefreshmanClass.from_dynamic!(d) + if schema[:prefreshman_class].right.valid? value + return new(prefreshman_class: value, null_array: nil, string: nil) + end + rescue + end + if schema[:string].right.valid? d + return new(string: d, null_array: nil, prefreshman_class: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if null_array != nil + null_array + elsif prefreshman_class != nil + prefreshman_class.to_dynamic + elsif string != nil + string + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Prehensility < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :monazite_class, MonaziteClass.optional + attribute :null_array, Types.Array(Types::Nil).optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, null_array: nil, monazite_class: nil) + end + begin + value = MonaziteClass.from_dynamic!(d) + if schema[:monazite_class].right.valid? value + return new(monazite_class: value, null_array: nil, bool: nil) + end + rescue + end + if schema[:null_array].right.valid? d + return new(null_array: d, bool: nil, monazite_class: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif monazite_class != nil + monazite_class.to_dynamic + elsif null_array != nil + null_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Prevoidance < Dry::Struct + attribute :integer, Types::Integer.optional + attribute :integer_array, Types.Array(Types::Integer).optional + attribute :monazite_class, MonaziteClass.optional + + def self.from_dynamic!(d) + if schema[:integer].right.valid? d + return new(integer: d, integer_array: nil, monazite_class: nil) + end + if schema[:integer_array].right.valid? d + return new(integer_array: d, monazite_class: nil, integer: nil) + end + begin + value = MonaziteClass.from_dynamic!(d) + if schema[:monazite_class].right.valid? value + return new(monazite_class: value, integer_array: nil, integer: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer != nil + integer + elsif integer_array != nil + integer_array + elsif monazite_class != nil + monazite_class.to_dynamic + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Protext < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :integer_array, Types.Array(Types::Integer).optional + attribute :monazite_class, MonaziteClass.optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, integer_array: nil, monazite_class: nil) + end + if schema[:integer_array].right.valid? d + return new(integer_array: d, bool: nil, monazite_class: nil) + end + begin + value = MonaziteClass.from_dynamic!(d) + if schema[:monazite_class].right.valid? value + return new(monazite_class: value, integer_array: nil, bool: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif integer_array != nil + integer_array + elsif monazite_class != nil + monazite_class.to_dynamic + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class TopLevel < Dry::Struct + attribute :juror, Types.Array(Types.Instance(JurorElement)) + attribute :kongoni, Types.Array(Types.Instance(Kongoni)) + attribute :ladronism, Types.Array(Types.Instance(LadronismElement)) + attribute :landlubberly, Types.Array(Types.Instance(LandlubberlyElement)) + attribute :listener, Types.Array(Types.Instance(Listener)) + attribute :lupus, Types.Array(Types.Instance(LupusElement)) + attribute :maslin, Types.Array(Maslin) + attribute :monazite, Types.Array(Types.Instance(MonaziteElement)) + attribute :monoliteral, Types.Array(Types.Instance(Monoliteral)) + attribute :monotheistically, Types.Array(Types.Instance(MonotheisticallyElement)) + attribute :montage, Types.Array(Types.Instance(Montage)) + attribute :moralness, Types.Array(Types.Instance(Moralness)) + attribute :mowra, Types.Array(MonaziteClass.optional) + attribute :mulishly, Types.Array(Types.Instance(Mulishly)) + attribute :myoscope, Types.Array(Types.Instance(Myoscope)) + attribute :nach, Types.Array(Types.Array(Types::Integer.optional).optional) + attribute :neuromastic, Types.Array(Types.Instance(Neuromastic)) + attribute :noncontributing, Types.Array(Noncontributing) + attribute :nonnervous, Types.Array(Types.Instance(Nonnervous)) + attribute :nonvaluation, Types.Array(Types.Instance(Nonvaluation)) + attribute :occupationalist, Types.Array(Types.Instance(OccupationalistElement)) + attribute :outrival, Types.Array(Types.Instance(OutrivalElement)) + attribute :paleographically, Types.Array(Types.Instance(Paleographically)) + attribute :pamphletwise, Types.Array(Types.Instance(Pamphletwise)) + attribute :pediatrics, Types.Array(Types.Instance(Pediatric)) + attribute :perceptive, Types.Array(Types::Bool) + attribute :piaculum, Types.Array(Types.Instance(PiaculumElement)) + attribute :piccadilly, Types.Array(Types.Instance(Piccadilly)) + attribute :piffler, Types.Array(Types.Instance(Piffler)) + attribute :pithful, Types.Array(Types.Instance(Pithful)) + attribute :placuntitis, Types.Array(Types.Instance(Placuntiti)) + attribute :plectopterous, Types.Array(Types.Instance(Plectopterous)) + attribute :pneumocele, Types.Array(Pneumocele.optional) + attribute :poliorcetic, Types.Array(Types.Instance(Poliorcetic)) + attribute :poormaster, Types.Array(Types.Instance(Poormaster)) + attribute :potwhisky, Types.Array(Types.Instance(PotwhiskyElement)) + attribute :practicalizer, Types.Array(Types.Instance(Practicalizer)) + attribute :prefreshman, Types.Array(Types.Instance(PrefreshmanElement)) + attribute :prehensility, Types.Array(Types.Instance(Prehensility)) + attribute :prevoidance, Types.Array(Types.Instance(Prevoidance)) + attribute :probant, Types.Array(Types::Hash.meta(of: Types::Integer.optional)) + attribute :protext, Types.Array(Types.Instance(Protext)) + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + juror: d.fetch("juror").map { |x| JurorElement.from_dynamic!(x) }, + kongoni: d.fetch("kongoni").map { |x| Kongoni.from_dynamic!(x) }, + ladronism: d.fetch("ladronism").map { |x| LadronismElement.from_dynamic!(x) }, + landlubberly: d.fetch("landlubberly").map { |x| LandlubberlyElement.from_dynamic!(x) }, + listener: d.fetch("listener").map { |x| Listener.from_dynamic!(x) }, + lupus: d.fetch("lupus").map { |x| LupusElement.from_dynamic!(x) }, + maslin: d.fetch("maslin").map { |x| Maslin.from_dynamic!(x) }, + monazite: d.fetch("monazite").map { |x| MonaziteElement.from_dynamic!(x) }, + monoliteral: d.fetch("monoliteral").map { |x| Monoliteral.from_dynamic!(x) }, + monotheistically: d.fetch("monotheistically").map { |x| MonotheisticallyElement.from_dynamic!(x) }, + montage: d.fetch("montage").map { |x| Montage.from_dynamic!(x) }, + moralness: d.fetch("moralness").map { |x| Moralness.from_dynamic!(x) }, + mowra: d.fetch("mowra").map { |x| x ? MonaziteClass.from_dynamic!(x) : nil }, + mulishly: d.fetch("mulishly").map { |x| Mulishly.from_dynamic!(x) }, + myoscope: d.fetch("myoscope").map { |x| Myoscope.from_dynamic!(x) }, + nach: d.fetch("nach"), + neuromastic: d.fetch("neuromastic").map { |x| Neuromastic.from_dynamic!(x) }, + noncontributing: d.fetch("noncontributing").map { |x| Noncontributing.from_dynamic!(x) }, + nonnervous: d.fetch("nonnervous").map { |x| Nonnervous.from_dynamic!(x) }, + nonvaluation: d.fetch("nonvaluation").map { |x| Nonvaluation.from_dynamic!(x) }, + occupationalist: d.fetch("occupationalist").map { |x| OccupationalistElement.from_dynamic!(x) }, + outrival: d.fetch("outrival").map { |x| OutrivalElement.from_dynamic!(x) }, + paleographically: d.fetch("paleographically").map { |x| Paleographically.from_dynamic!(x) }, + pamphletwise: d.fetch("pamphletwise").map { |x| Pamphletwise.from_dynamic!(x) }, + pediatrics: d.fetch("pediatrics").map { |x| Pediatric.from_dynamic!(x) }, + perceptive: d.fetch("perceptive"), + piaculum: d.fetch("piaculum").map { |x| PiaculumElement.from_dynamic!(x) }, + piccadilly: d.fetch("piccadilly").map { |x| Piccadilly.from_dynamic!(x) }, + piffler: d.fetch("piffler").map { |x| Piffler.from_dynamic!(x) }, + pithful: d.fetch("pithful").map { |x| Pithful.from_dynamic!(x) }, + placuntitis: d.fetch("placuntitis").map { |x| Placuntiti.from_dynamic!(x) }, + plectopterous: d.fetch("plectopterous").map { |x| Plectopterous.from_dynamic!(x) }, + pneumocele: d.fetch("pneumocele").map { |x| x ? Pneumocele.from_dynamic!(x) : nil }, + poliorcetic: d.fetch("poliorcetic").map { |x| Poliorcetic.from_dynamic!(x) }, + poormaster: d.fetch("poormaster").map { |x| Poormaster.from_dynamic!(x) }, + potwhisky: d.fetch("potwhisky").map { |x| PotwhiskyElement.from_dynamic!(x) }, + practicalizer: d.fetch("practicalizer").map { |x| Practicalizer.from_dynamic!(x) }, + prefreshman: d.fetch("prefreshman").map { |x| PrefreshmanElement.from_dynamic!(x) }, + prehensility: d.fetch("prehensility").map { |x| Prehensility.from_dynamic!(x) }, + prevoidance: d.fetch("prevoidance").map { |x| Prevoidance.from_dynamic!(x) }, + probant: d.fetch("probant").map { |x| Types::Hash[x].map { |k, v| [k, v] }.to_h }, + protext: d.fetch("protext").map { |x| Protext.from_dynamic!(x) }, + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "juror" => juror.map { |x| x.to_dynamic }, + "kongoni" => kongoni.map { |x| x.to_dynamic }, + "ladronism" => ladronism.map { |x| x.to_dynamic }, + "landlubberly" => landlubberly.map { |x| x.to_dynamic }, + "listener" => listener.map { |x| x.to_dynamic }, + "lupus" => lupus.map { |x| x.to_dynamic }, + "maslin" => maslin.map { |x| x.to_dynamic }, + "monazite" => monazite.map { |x| x.to_dynamic }, + "monoliteral" => monoliteral.map { |x| x.to_dynamic }, + "monotheistically" => monotheistically.map { |x| x.to_dynamic }, + "montage" => montage.map { |x| x.to_dynamic }, + "moralness" => moralness.map { |x| x.to_dynamic }, + "mowra" => mowra.map { |x| x&.to_dynamic }, + "mulishly" => mulishly.map { |x| x.to_dynamic }, + "myoscope" => myoscope.map { |x| x.to_dynamic }, + "nach" => nach, + "neuromastic" => neuromastic.map { |x| x.to_dynamic }, + "noncontributing" => noncontributing.map { |x| x.to_dynamic }, + "nonnervous" => nonnervous.map { |x| x.to_dynamic }, + "nonvaluation" => nonvaluation.map { |x| x.to_dynamic }, + "occupationalist" => occupationalist.map { |x| x.to_dynamic }, + "outrival" => outrival.map { |x| x.to_dynamic }, + "paleographically" => paleographically.map { |x| x.to_dynamic }, + "pamphletwise" => pamphletwise.map { |x| x.to_dynamic }, + "pediatrics" => pediatrics.map { |x| x.to_dynamic }, + "perceptive" => perceptive, + "piaculum" => piaculum.map { |x| x.to_dynamic }, + "piccadilly" => piccadilly.map { |x| x.to_dynamic }, + "piffler" => piffler.map { |x| x.to_dynamic }, + "pithful" => pithful.map { |x| x.to_dynamic }, + "placuntitis" => placuntitis.map { |x| x.to_dynamic }, + "plectopterous" => plectopterous.map { |x| x.to_dynamic }, + "pneumocele" => pneumocele.map { |x| x&.to_dynamic }, + "poliorcetic" => poliorcetic.map { |x| x.to_dynamic }, + "poormaster" => poormaster.map { |x| x.to_dynamic }, + "potwhisky" => potwhisky.map { |x| x.to_dynamic }, + "practicalizer" => practicalizer.map { |x| x.to_dynamic }, + "prefreshman" => prefreshman.map { |x| x.to_dynamic }, + "prehensility" => prehensility.map { |x| x.to_dynamic }, + "prevoidance" => prevoidance.map { |x| x.to_dynamic }, + "probant" => probant, + "protext" => protext.map { |x| x.to_dynamic }, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end diff --git a/head/ruby/test/inputs/json/priority/combinations4.json/default/TopLevel.rb b/head/ruby/test/inputs/json/priority/combinations4.json/default/TopLevel.rb new file mode 100644 index 0000000..61299ab --- /dev/null +++ b/head/ruby/test/inputs/json/priority/combinations4.json/default/TopLevel.rb @@ -0,0 +1,3113 @@ +# This code may look unusually verbose for Ruby (and it is), but +# it performs some subtle and complex validation of JSON data. +# +# To parse this JSON, add 'dry-struct' and 'dry-types' gems, then do: +# +# top_level = TopLevel.from_json! "{…}" +# puts top_level.wrothy.first +# +# If from_json! succeeds, the value returned matches the schema. + +require 'json' +require 'dry-types' +require 'dry-struct' + +module Types + include Dry.Types(default: :nominal) + + Integer = Strict::Integer + Nil = Strict::Nil + Bool = Strict::Bool + Hash = Strict::Hash + String = Strict::String + Double = Strict::Float | Strict::Integer +end + +class Protrusive < Dry::Struct + attribute :double, Types::Double.optional + attribute :union_array, Types.Array(Types::Integer.optional).optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, union_array: nil) + end + if schema[:union_array].right.valid? d + return new(union_array: d, double: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif union_array != nil + union_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class PulpitismClass < Dry::Struct + attribute :abnet, Types::Nil + attribute :buckhorn, Types::Nil + attribute :calciform, Types::Nil + attribute :chelophore, Types::Nil + attribute :cogitation, Types::Nil + attribute :decreeable, Types::Nil + attribute :despicable, Types::Nil + attribute :isodiazo, Types::Nil + attribute :jadedly, Types::Nil + attribute :leptochlorite, Types::Nil + attribute :nursling, Types::Nil + attribute :palamedean, Types::Nil + attribute :photoheliograph, Types::Nil + attribute :pipewood, Types::Nil + attribute :roberd, Types::Nil + attribute :statable, Types::Nil + attribute :superassume, Types::Nil + attribute :syllabe, Types::Nil + attribute :toughhead, Types::Nil + attribute :underburn, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + abnet: d.fetch("abnet"), + buckhorn: d.fetch("buckhorn"), + calciform: d.fetch("calciform"), + chelophore: d.fetch("chelophore"), + cogitation: d.fetch("cogitation"), + decreeable: d.fetch("decreeable"), + despicable: d.fetch("despicable"), + isodiazo: d.fetch("isodiazo"), + jadedly: d.fetch("jadedly"), + leptochlorite: d.fetch("leptochlorite"), + nursling: d.fetch("nursling"), + palamedean: d.fetch("palamedean"), + photoheliograph: d.fetch("photoheliograph"), + pipewood: d.fetch("pipewood"), + roberd: d.fetch("roberd"), + statable: d.fetch("statable"), + superassume: d.fetch("superassume"), + syllabe: d.fetch("syllabe"), + toughhead: d.fetch("toughhead"), + underburn: d.fetch("underburn"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class PulpitismElement < Dry::Struct + attribute :double, Types::Double.optional + attribute :integer_array, Types.Array(Types::Integer).optional + attribute :pulpitism_class, PulpitismClass.optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, integer_array: nil, pulpitism_class: nil) + end + if schema[:integer_array].right.valid? d + return new(integer_array: d, pulpitism_class: nil, double: nil) + end + begin + value = PulpitismClass.from_dynamic!(d) + if schema[:pulpitism_class].right.valid? value + return new(pulpitism_class: value, integer_array: nil, double: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif integer_array != nil + integer_array + elsif pulpitism_class != nil + pulpitism_class.to_dynamic + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class PyodermiaClass < Dry::Struct + attribute :aphoristically, Types::Nil + attribute :apophyllous, Types::Nil + attribute :cognize, Types::Nil + attribute :dermonosology, Types::Nil + attribute :gyppo, Types::Nil + attribute :ither, Types::Nil + attribute :juglandaceous, Types::Nil + attribute :litho, Types::Nil + attribute :macropterous, Types::Nil + attribute :photographer, Types::Nil + attribute :romancing, Types::Nil + attribute :rumness, Types::Nil + attribute :somniloquist, Types::Nil + attribute :stressfully, Types::Nil + attribute :tactically, Types::Nil + attribute :tracheophony, Types::Nil + attribute :unappositely, Types::Nil + attribute :unclothedly, Types::Nil + attribute :unimplied, Types::Nil + attribute :unsyncopated, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + aphoristically: d.fetch("aphoristically"), + apophyllous: d.fetch("apophyllous"), + cognize: d.fetch("cognize"), + dermonosology: d.fetch("dermonosology"), + gyppo: d.fetch("Gyppo"), + ither: d.fetch("ither"), + juglandaceous: d.fetch("juglandaceous"), + litho: d.fetch("litho"), + macropterous: d.fetch("macropterous"), + photographer: d.fetch("photographer"), + romancing: d.fetch("romancing"), + rumness: d.fetch("rumness"), + somniloquist: d.fetch("somniloquist"), + stressfully: d.fetch("stressfully"), + tactically: d.fetch("tactically"), + tracheophony: d.fetch("tracheophony"), + unappositely: d.fetch("unappositely"), + unclothedly: d.fetch("unclothedly"), + unimplied: d.fetch("unimplied"), + unsyncopated: d.fetch("unsyncopated"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class PyodermiaElement < Dry::Struct + attribute :integer, Types::Integer.optional + attribute :pyodermia_class, PyodermiaClass.optional + + def self.from_dynamic!(d) + if schema[:integer].right.valid? d + return new(integer: d, pyodermia_class: nil) + end + begin + value = PyodermiaClass.from_dynamic!(d) + if schema[:pyodermia_class].right.valid? value + return new(pyodermia_class: value, integer: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer != nil + integer + elsif pyodermia_class != nil + pyodermia_class.to_dynamic + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class QuebrachineClass < Dry::Struct + attribute :catharticalness, Types::Double + attribute :chirotherium, Types::Integer + attribute :disdiapason, Types::String + attribute :homocerc, Types::Bool + attribute :nonbookish, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + catharticalness: d.fetch("catharticalness"), + chirotherium: d.fetch("Chirotherium"), + disdiapason: d.fetch("disdiapason"), + homocerc: d.fetch("homocerc"), + nonbookish: d.fetch("nonbookish"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "catharticalness" => catharticalness, + "Chirotherium" => chirotherium, + "disdiapason" => disdiapason, + "homocerc" => homocerc, + "nonbookish" => nonbookish, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class QuebrachineElement < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :null, Types::Nil.optional + attribute :quebrachine_class, QuebrachineClass.optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, quebrachine_class: nil, null: nil) + end + if schema[:null].right.valid? d + return new(null: d, bool: nil, quebrachine_class: nil) + end + begin + value = QuebrachineClass.from_dynamic!(d) + if schema[:quebrachine_class].right.valid? value + return new(quebrachine_class: value, bool: nil, null: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif quebrachine_class != nil + quebrachine_class.to_dynamic + else + nil + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Querier < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :integer_map, Types::Hash.meta(of: Types::Integer).optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, integer_map: nil) + end + begin + value = Types::Hash[d].map { |k, v| [k, Types::Integer[v]] }.to_h + if schema[:integer_map].right.valid? value + return new(integer_map: value, bool: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif integer_map != nil + integer_map + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Rebarbative < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :double, Types::Double.optional + attribute :integer_array, Types.Array(Types::Integer).optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, integer_array: nil, double: nil) + end + if schema[:double].right.valid? d + return new(double: d, integer_array: nil, bool: nil) + end + if schema[:integer_array].right.valid? d + return new(integer_array: d, bool: nil, double: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif double != nil + double + elsif integer_array != nil + integer_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Reimagine < Dry::Struct + attribute :adducible, Types::Nil.optional + attribute :anabolin, Types::Nil.optional + attribute :brainy, Types::Nil.optional + attribute :catharticalness, Types::Double.optional + attribute :chirotherium, Types::Integer.optional + attribute :chrysamine, Types::Nil.optional + attribute :disdiapason, Types::String.optional + attribute :fluxweed, Types::Nil.optional + attribute :glaucine, Types::Nil.optional + attribute :grobianism, Types::Nil.optional + attribute :hermo, Types::Nil.optional + attribute :hieroglyphist, Types::Nil.optional + attribute :homocerc, Types::Bool.optional + attribute :icteroid, Types::Nil.optional + attribute :immortal, Types::Nil.optional + attribute :impetulant, Types::Nil.optional + attribute :irrigate, Types::Nil.optional + attribute :myxedema, Types::Nil.optional + attribute :nonbookish, Types::Nil.optional + attribute :onyx, Types::Nil.optional + attribute :repasser, Types::Nil.optional + attribute :septomarginal, Types::Nil.optional + attribute :subdie, Types::Nil.optional + attribute :tibiometatarsal, Types::Nil.optional + attribute :waltzlike, Types::Nil.optional + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + adducible: d["adducible"], + anabolin: d["anabolin"], + brainy: d["brainy"], + catharticalness: d["catharticalness"], + chirotherium: d["Chirotherium"], + chrysamine: d["chrysamine"], + disdiapason: d["disdiapason"], + fluxweed: d["fluxweed"], + glaucine: d["glaucine"], + grobianism: d["grobianism"], + hermo: d["Hermo"], + hieroglyphist: d["hieroglyphist"], + homocerc: d["homocerc"], + icteroid: d["icteroid"], + immortal: d["immortal"], + impetulant: d["impetulant"], + irrigate: d["irrigate"], + myxedema: d["myxedema"], + nonbookish: d["nonbookish"], + onyx: d["onyx"], + repasser: d["repasser"], + septomarginal: d["septomarginal"], + subdie: d["subdie"], + tibiometatarsal: d["tibiometatarsal"], + waltzlike: d["waltzlike"], + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Ressaut < Dry::Struct + attribute :apperceptive, Types::String + attribute :cuttoo, Types::String + attribute :douser, Types::String + attribute :drinkproof, Types::String + attribute :forementioned, Types::String + attribute :freesia, Types::String + attribute :genevieve, Types::String + attribute :hyperdiabolical, Types::String + attribute :hypocone, Types::String + attribute :irreverentially, Types::String + attribute :jumart, Types::String + attribute :mimosaceae, Types::String + attribute :mollicrush, Types::String + attribute :nedder, Types::String + attribute :retinasphalt, Types::String + attribute :sough, Types::String + attribute :steading, Types::String + attribute :theopaschitism, Types::String + attribute :undurableness, Types::String + attribute :unmingleable, Types::String + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + apperceptive: d.fetch("apperceptive"), + cuttoo: d.fetch("cuttoo"), + douser: d.fetch("douser"), + drinkproof: d.fetch("drinkproof"), + forementioned: d.fetch("forementioned"), + freesia: d.fetch("Freesia"), + genevieve: d.fetch("Genevieve"), + hyperdiabolical: d.fetch("hyperdiabolical"), + hypocone: d.fetch("hypocone"), + irreverentially: d.fetch("irreverentially"), + jumart: d.fetch("jumart"), + mimosaceae: d.fetch("Mimosaceae"), + mollicrush: d.fetch("mollicrush"), + nedder: d.fetch("nedder"), + retinasphalt: d.fetch("retinasphalt"), + sough: d.fetch("sough"), + steading: d.fetch("steading"), + theopaschitism: d.fetch("Theopaschitism"), + undurableness: d.fetch("undurableness"), + unmingleable: d.fetch("unmingleable"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Retrocervical < Dry::Struct + attribute :integer, Types::Integer.optional + attribute :union_array, Types.Array(Types::Integer.optional).optional + + def self.from_dynamic!(d) + if schema[:integer].right.valid? d + return new(integer: d, union_array: nil) + end + if schema[:union_array].right.valid? d + return new(union_array: d, integer: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer != nil + integer + elsif union_array != nil + union_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Revert < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, string: nil) + end + if schema[:string].right.valid? d + return new(string: d, bool: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif string != nil + string + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class RewriteClass < Dry::Struct + attribute :accountancy, Types::Nil + attribute :cacotrophic, Types::Nil + attribute :contest, Types::Nil + attribute :couthily, Types::Nil + attribute :falculate, Types::Nil + attribute :foreseize, Types::Nil + attribute :hyades, Types::Nil + attribute :lemnad, Types::Nil + attribute :monotheistically, Types::Nil + attribute :nonflying, Types::Nil + attribute :ptenoglossa, Types::Nil + attribute :repatch, Types::Nil + attribute :rodman, Types::Nil + attribute :strung, Types::Nil + attribute :titmal, Types::Nil + attribute :twalpennyworth, Types::Nil + attribute :unblamable, Types::Nil + attribute :vertical, Types::Nil + attribute :whiggification, Types::Nil + attribute :yardman, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + accountancy: d.fetch("accountancy"), + cacotrophic: d.fetch("cacotrophic"), + contest: d.fetch("contest"), + couthily: d.fetch("couthily"), + falculate: d.fetch("falculate"), + foreseize: d.fetch("foreseize"), + hyades: d.fetch("Hyades"), + lemnad: d.fetch("lemnad"), + monotheistically: d.fetch("monotheistically"), + nonflying: d.fetch("nonflying"), + ptenoglossa: d.fetch("Ptenoglossa"), + repatch: d.fetch("repatch"), + rodman: d.fetch("rodman"), + strung: d.fetch("strung"), + titmal: d.fetch("titmal"), + twalpennyworth: d.fetch("twalpennyworth"), + unblamable: d.fetch("unblamable"), + vertical: d.fetch("vertical"), + whiggification: d.fetch("Whiggification"), + yardman: d.fetch("yardman"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class RewriteElement < Dry::Struct + attribute :double, Types::Double.optional + attribute :null_array, Types.Array(Types::Nil).optional + attribute :rewrite_class, RewriteClass.optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, null_array: nil, rewrite_class: nil) + end + if schema[:null_array].right.valid? d + return new(null_array: d, rewrite_class: nil, double: nil) + end + begin + value = RewriteClass.from_dynamic!(d) + if schema[:rewrite_class].right.valid? value + return new(rewrite_class: value, null_array: nil, double: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif null_array != nil + null_array + elsif rewrite_class != nil + rewrite_class.to_dynamic + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Saccoderm < Dry::Struct + attribute :integer_array, Types.Array(Types::Integer).optional + attribute :null, Types::Nil.optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + if schema[:integer_array].right.valid? d + return new(integer_array: d, null: nil, string: nil) + end + if schema[:null].right.valid? d + return new(null: d, integer_array: nil, string: nil) + end + if schema[:string].right.valid? d + return new(string: d, integer_array: nil, null: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer_array != nil + integer_array + elsif string != nil + string + else + nil + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class SantirClass < Dry::Struct + attribute :admiredly, Types::Nil + attribute :demicaponier, Types::Nil + attribute :epitympanic, Types::Nil + attribute :investitor, Types::Nil + attribute :lupiform, Types::Nil + attribute :monoflagellate, Types::Nil + attribute :paleoethnic, Types::Nil + attribute :prediscountable, Types::Nil + attribute :rhetoricals, Types::Nil + attribute :roomth, Types::Nil + attribute :saccharose, Types::Nil + attribute :septonasal, Types::Nil + attribute :serpenticide, Types::Nil + attribute :setarious, Types::Nil + attribute :spaework, Types::Nil + attribute :stylite, Types::Nil + attribute :suessiones, Types::Nil + attribute :timelily, Types::Nil + attribute :unprofaned, Types::Nil + attribute :vorticular, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + admiredly: d.fetch("admiredly"), + demicaponier: d.fetch("demicaponier"), + epitympanic: d.fetch("epitympanic"), + investitor: d.fetch("investitor"), + lupiform: d.fetch("lupiform"), + monoflagellate: d.fetch("monoflagellate"), + paleoethnic: d.fetch("paleoethnic"), + prediscountable: d.fetch("prediscountable"), + rhetoricals: d.fetch("rhetoricals"), + roomth: d.fetch("roomth"), + saccharose: d.fetch("saccharose"), + septonasal: d.fetch("septonasal"), + serpenticide: d.fetch("serpenticide"), + setarious: d.fetch("setarious"), + spaework: d.fetch("spaework"), + stylite: d.fetch("stylite"), + suessiones: d.fetch("Suessiones"), + timelily: d.fetch("timelily"), + unprofaned: d.fetch("unprofaned"), + vorticular: d.fetch("vorticular"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class SantirElement < Dry::Struct + attribute :double, Types::Double.optional + attribute :santir_class, SantirClass.optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, santir_class: nil) + end + begin + value = SantirClass.from_dynamic!(d) + if schema[:santir_class].right.valid? value + return new(santir_class: value, double: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif santir_class != nil + santir_class.to_dynamic + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Saprophilous < Dry::Struct + attribute :integer_map, Types::Hash.meta(of: Types::Integer).optional + attribute :null, Types::Nil.optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + begin + value = Types::Hash[d].map { |k, v| [k, Types::Integer[v]] }.to_h + if schema[:integer_map].right.valid? value + return new(integer_map: value, null: nil, string: nil) + end + rescue + end + if schema[:null].right.valid? d + return new(null: d, integer_map: nil, string: nil) + end + if schema[:string].right.valid? d + return new(string: d, integer_map: nil, null: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer_map != nil + integer_map + elsif string != nil + string + else + nil + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class SaxtenClass < Dry::Struct + attribute :algarrobilla, Types::Nil.optional + attribute :bowgrace, Types::Nil.optional + attribute :catharticalness, Types::Double.optional + attribute :centaurid, Types::Nil.optional + attribute :chirotherium, Types::Integer.optional + attribute :disdiapason, Types::String.optional + attribute :flix, Types::Nil.optional + attribute :germanely, Types::Nil.optional + attribute :homocerc, Types::Bool.optional + attribute :inhume, Types::Nil.optional + attribute :lepidote, Types::Nil.optional + attribute :megalochirous, Types::Nil.optional + attribute :ninepenny, Types::Nil.optional + attribute :nonbookish, Types::Nil.optional + attribute :nondeist, Types::Nil.optional + attribute :nymphaeaceous, Types::Nil.optional + attribute :parietofrontal, Types::Nil.optional + attribute :sancyite, Types::Nil.optional + attribute :subjectivist, Types::Nil.optional + attribute :tibiad, Types::Nil.optional + attribute :transonic, Types::Nil.optional + attribute :tripetalous, Types::Nil.optional + attribute :trunchman, Types::Nil.optional + attribute :urger, Types::Nil.optional + attribute :withdrawnness, Types::Nil.optional + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + algarrobilla: d["algarrobilla"], + bowgrace: d["bowgrace"], + catharticalness: d["catharticalness"], + centaurid: d["Centaurid"], + chirotherium: d["Chirotherium"], + disdiapason: d["disdiapason"], + flix: d["flix"], + germanely: d["germanely"], + homocerc: d["homocerc"], + inhume: d["inhume"], + lepidote: d["lepidote"], + megalochirous: d["megalochirous"], + ninepenny: d["ninepenny"], + nonbookish: d["nonbookish"], + nondeist: d["nondeist"], + nymphaeaceous: d["nymphaeaceous"], + parietofrontal: d["parietofrontal"], + sancyite: d["sancyite"], + subjectivist: d["subjectivist"], + tibiad: d["tibiad"], + transonic: d["transonic"], + tripetalous: d["tripetalous"], + trunchman: d["trunchman"], + urger: d["urger"], + withdrawnness: d["withdrawnness"], + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class SaxtenElement < Dry::Struct + attribute :saxten_class, SaxtenClass.optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + begin + value = SaxtenClass.from_dynamic!(d) + if schema[:saxten_class].right.valid? value + return new(saxten_class: value, string: nil) + end + rescue + end + if schema[:string].right.valid? d + return new(string: d, saxten_class: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if saxten_class != nil + saxten_class.to_dynamic + elsif string != nil + string + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Scatty < Dry::Struct + attribute :aeriferous, Types::Nil + attribute :antical, Types::Nil + attribute :antighostism, Types::Nil + attribute :arcanum, Types::Nil + attribute :autotrophy, Types::Nil + attribute :baronial, Types::Nil + attribute :caffeine, Types::Nil + attribute :gorgoniacean, Types::Nil + attribute :heroical, Types::Nil + attribute :hydropical, Types::Nil + attribute :mechanology, Types::Nil + attribute :musicopoetic, Types::Nil + attribute :officiality, Types::Nil + attribute :oftentimes, Types::Nil + attribute :ophthalmotonometer, Types::Nil + attribute :reflectively, Types::Nil + attribute :springer, Types::Nil + attribute :tabasco, Types::Nil + attribute :teleianthous, Types::Nil + attribute :uncombated, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + aeriferous: d.fetch("aeriferous"), + antical: d.fetch("antical"), + antighostism: d.fetch("antighostism"), + arcanum: d.fetch("arcanum"), + autotrophy: d.fetch("autotrophy"), + baronial: d.fetch("baronial"), + caffeine: d.fetch("caffeine"), + gorgoniacean: d.fetch("gorgoniacean"), + heroical: d.fetch("heroical"), + hydropical: d.fetch("hydropical"), + mechanology: d.fetch("mechanology"), + musicopoetic: d.fetch("musicopoetic"), + officiality: d.fetch("officiality"), + oftentimes: d.fetch("oftentimes"), + ophthalmotonometer: d.fetch("ophthalmotonometer"), + reflectively: d.fetch("reflectively"), + springer: d.fetch("springer"), + tabasco: d.fetch("Tabasco"), + teleianthous: d.fetch("teleianthous"), + uncombated: d.fetch("uncombated"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Scoffer < Dry::Struct + attribute :integer_map, Types::Hash.meta(of: Types::Integer).optional + attribute :null, Types::Nil.optional + attribute :null_array, Types.Array(Types::Nil).optional + + def self.from_dynamic!(d) + begin + value = Types::Hash[d].map { |k, v| [k, Types::Integer[v]] }.to_h + if schema[:integer_map].right.valid? value + return new(integer_map: value, null_array: nil, null: nil) + end + rescue + end + if schema[:null].right.valid? d + return new(null: d, null_array: nil, integer_map: nil) + end + if schema[:null_array].right.valid? d + return new(null_array: d, integer_map: nil, null: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer_map != nil + integer_map + elsif null_array != nil + null_array + else + nil + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Scrampum < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :integer_array, Types.Array(Types::Integer).optional + attribute :null, Types::Nil.optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, integer_array: nil, null: nil) + end + if schema[:integer_array].right.valid? d + return new(integer_array: d, bool: nil, null: nil) + end + if schema[:null].right.valid? d + return new(null: d, integer_array: nil, bool: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif integer_array != nil + integer_array + else + nil + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Serpentinic < Dry::Struct + attribute :double, Types::Double.optional + attribute :integer_array, Types.Array(Types::Integer).optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, integer_array: nil) + end + if schema[:integer_array].right.valid? d + return new(integer_array: d, double: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif integer_array != nil + integer_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Shadowable < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :union_array, Types.Array(Types::Integer.optional).optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, union_array: nil) + end + if schema[:union_array].right.valid? d + return new(union_array: d, bool: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif union_array != nil + union_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class SisteringClass < Dry::Struct + attribute :amphicarpic, Types::Nil + attribute :chianti, Types::Nil + attribute :frigorific, Types::Nil + attribute :haplomi, Types::Nil + attribute :hyperkinesis, Types::Nil + attribute :laudable, Types::Nil + attribute :madwoman, Types::Nil + attribute :maimedly, Types::Nil + attribute :micropterygidae, Types::Nil + attribute :microrhabdus, Types::Nil + attribute :nondense, Types::Nil + attribute :phlebemphraxis, Types::Nil + attribute :redsear, Types::Nil + attribute :schismatical, Types::Nil + attribute :tartryl, Types::Nil + attribute :unabhorred, Types::Nil + attribute :undeliberateness, Types::Nil + attribute :unmixable, Types::Nil + attribute :untruckling, Types::Nil + attribute :vineal, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + amphicarpic: d.fetch("amphicarpic"), + chianti: d.fetch("Chianti"), + frigorific: d.fetch("frigorific"), + haplomi: d.fetch("Haplomi"), + hyperkinesis: d.fetch("hyperkinesis"), + laudable: d.fetch("laudable"), + madwoman: d.fetch("madwoman"), + maimedly: d.fetch("maimedly"), + micropterygidae: d.fetch("Micropterygidae"), + microrhabdus: d.fetch("microrhabdus"), + nondense: d.fetch("nondense"), + phlebemphraxis: d.fetch("phlebemphraxis"), + redsear: d.fetch("redsear"), + schismatical: d.fetch("schismatical"), + tartryl: d.fetch("tartryl"), + unabhorred: d.fetch("unabhorred"), + undeliberateness: d.fetch("undeliberateness"), + unmixable: d.fetch("unmixable"), + untruckling: d.fetch("untruckling"), + vineal: d.fetch("vineal"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class SisteringElement < Dry::Struct + attribute :integer, Types::Integer.optional + attribute :null_array, Types.Array(Types::Nil).optional + attribute :sistering_class, SisteringClass.optional + + def self.from_dynamic!(d) + if schema[:integer].right.valid? d + return new(integer: d, null_array: nil, sistering_class: nil) + end + if schema[:null_array].right.valid? d + return new(null_array: d, sistering_class: nil, integer: nil) + end + begin + value = SisteringClass.from_dynamic!(d) + if schema[:sistering_class].right.valid? value + return new(sistering_class: value, null_array: nil, integer: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer != nil + integer + elsif null_array != nil + null_array + elsif sistering_class != nil + sistering_class.to_dynamic + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Staghunting < Dry::Struct + attribute :calorimetric, Types::Integer.optional + attribute :canid, Types::Integer.optional + attribute :catharticalness, Types::Double.optional + attribute :chirotherium, Types::Integer.optional + attribute :disdiapason, Types::String.optional + attribute :ditriglyphic, Types::Integer.optional + attribute :floriferousness, Types::Integer.optional + attribute :gamelike, Types::Integer.optional + attribute :grig, Types::Integer.optional + attribute :homocerc, Types::Bool.optional + attribute :interloan, Types::Integer.optional + attribute :lithotomy, Types::Integer.optional + attribute :loric, Types::Integer.optional + attribute :membranocoriaceous, Types::Integer.optional + attribute :membranogenic, Types::Integer.optional + attribute :nonbookish, Types::Nil.optional + attribute :overtrump, Types::Integer.optional + attribute :scotino, Types::Integer.optional + attribute :seasonable, Types::Integer.optional + attribute :sephen, Types::Integer.optional + attribute :stigmarioid, Types::Integer.optional + attribute :tired, Types::Integer.optional + attribute :trifid, Types::Integer.optional + attribute :undefeatedly, Types::Integer.optional + attribute :ungirlish, Types::Integer.optional + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + calorimetric: d["calorimetric"], + canid: d["canid"], + catharticalness: d["catharticalness"], + chirotherium: d["Chirotherium"], + disdiapason: d["disdiapason"], + ditriglyphic: d["ditriglyphic"], + floriferousness: d["floriferousness"], + gamelike: d["gamelike"], + grig: d["grig"], + homocerc: d["homocerc"], + interloan: d["interloan"], + lithotomy: d["lithotomy"], + loric: d["loric"], + membranocoriaceous: d["membranocoriaceous"], + membranogenic: d["membranogenic"], + nonbookish: d["nonbookish"], + overtrump: d["overtrump"], + scotino: d["scotino"], + seasonable: d["seasonable"], + sephen: d["sephen"], + stigmarioid: d["stigmarioid"], + tired: d["tired"], + trifid: d["trifid"], + undefeatedly: d["undefeatedly"], + ungirlish: d["ungirlish"], + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Stagmometer < Dry::Struct + attribute :string, Types::String.optional + attribute :union_array, Types.Array(Types::Integer.optional).optional + + def self.from_dynamic!(d) + if schema[:string].right.valid? d + return new(string: d, union_array: nil) + end + if schema[:union_array].right.valid? d + return new(union_array: d, string: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if string != nil + string + elsif union_array != nil + union_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Stimulability < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :integer, Types::Integer.optional + attribute :integer_map, Types::Hash.meta(of: Types::Integer).optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, integer: nil, integer_map: nil) + end + if schema[:integer].right.valid? d + return new(integer: d, bool: nil, integer_map: nil) + end + begin + value = Types::Hash[d].map { |k, v| [k, Types::Integer[v]] }.to_h + if schema[:integer_map].right.valid? value + return new(integer_map: value, bool: nil, integer: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif integer != nil + integer + elsif integer_map != nil + integer_map + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Strangleable < Dry::Struct + attribute :double, Types::Double.optional + attribute :null_array, Types.Array(Types::Nil).optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, null_array: nil) + end + if schema[:null_array].right.valid? d + return new(null_array: d, double: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif null_array != nil + null_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class StrenuosityClass < Dry::Struct + attribute :bliss, Types::Integer.optional + attribute :buccate, Types::Integer.optional + attribute :bulletproof, Types::Integer.optional + attribute :catharticalness, Types::Double.optional + attribute :chirotherium, Types::Integer.optional + attribute :crumblingness, Types::Integer.optional + attribute :disdiapason, Types::String.optional + attribute :engagedly, Types::Integer.optional + attribute :fightable, Types::Integer.optional + attribute :hoariness, Types::Integer.optional + attribute :homocerc, Types::Bool.optional + attribute :hypopodium, Types::Integer.optional + attribute :luxurist, Types::Integer.optional + attribute :mechanician, Types::Integer.optional + attribute :nonbookish, Types::Nil.optional + attribute :onopordon, Types::Integer.optional + attribute :podgily, Types::Integer.optional + attribute :reformableness, Types::Integer.optional + attribute :scatterbrains, Types::Integer.optional + attribute :seminuria, Types::Integer.optional + attribute :sodomite, Types::Integer.optional + attribute :tramp, Types::Integer.optional + attribute :undueness, Types::Integer.optional + attribute :worthily, Types::Integer.optional + attribute :yankeeist, Types::Integer.optional + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + bliss: d["bliss"], + buccate: d["buccate"], + bulletproof: d["bulletproof"], + catharticalness: d["catharticalness"], + chirotherium: d["Chirotherium"], + crumblingness: d["crumblingness"], + disdiapason: d["disdiapason"], + engagedly: d["engagedly"], + fightable: d["fightable"], + hoariness: d["hoariness"], + homocerc: d["homocerc"], + hypopodium: d["hypopodium"], + luxurist: d["luxurist"], + mechanician: d["mechanician"], + nonbookish: d["nonbookish"], + onopordon: d["Onopordon"], + podgily: d["podgily"], + reformableness: d["reformableness"], + scatterbrains: d["scatterbrains"], + seminuria: d["seminuria"], + sodomite: d["Sodomite"], + tramp: d["tramp"], + undueness: d["undueness"], + worthily: d["worthily"], + yankeeist: d["Yankeeist"], + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class StrenuosityElement < Dry::Struct + attribute :null_array, Types.Array(Types::Nil).optional + attribute :strenuosity_class, StrenuosityClass.optional + + def self.from_dynamic!(d) + if schema[:null_array].right.valid? d + return new(null_array: d, strenuosity_class: nil) + end + begin + value = StrenuosityClass.from_dynamic!(d) + if schema[:strenuosity_class].right.valid? value + return new(strenuosity_class: value, null_array: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if null_array != nil + null_array + elsif strenuosity_class != nil + strenuosity_class.to_dynamic + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Tabaxir < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :double, Types::Double.optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, double: nil) + end + if schema[:double].right.valid? d + return new(double: d, bool: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif double != nil + double + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Talpiform < Dry::Struct + attribute :double, Types::Double.optional + attribute :null, Types::Nil.optional + attribute :quebrachine_class, QuebrachineClass.optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, quebrachine_class: nil, null: nil) + end + if schema[:null].right.valid? d + return new(null: d, quebrachine_class: nil, double: nil) + end + begin + value = QuebrachineClass.from_dynamic!(d) + if schema[:quebrachine_class].right.valid? value + return new(quebrachine_class: value, double: nil, null: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif quebrachine_class != nil + quebrachine_class.to_dynamic + else + nil + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Thwack < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :double, Types::Double.optional + attribute :quebrachine_class, QuebrachineClass.optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, quebrachine_class: nil, double: nil) + end + if schema[:double].right.valid? d + return new(double: d, bool: nil, quebrachine_class: nil) + end + begin + value = QuebrachineClass.from_dynamic!(d) + if schema[:quebrachine_class].right.valid? value + return new(quebrachine_class: value, bool: nil, double: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif double != nil + double + elsif quebrachine_class != nil + quebrachine_class.to_dynamic + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Tortricine < Dry::Struct + attribute :quebrachine_class, QuebrachineClass.optional + attribute :union_array, Types.Array(Types::Integer.optional).optional + + def self.from_dynamic!(d) + begin + value = QuebrachineClass.from_dynamic!(d) + if schema[:quebrachine_class].right.valid? value + return new(quebrachine_class: value, union_array: nil) + end + rescue + end + if schema[:union_array].right.valid? d + return new(union_array: d, quebrachine_class: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if quebrachine_class != nil + quebrachine_class.to_dynamic + elsif union_array != nil + union_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class TruantcyClass < Dry::Struct + attribute :alfiona, Types::Nil.optional + attribute :ascaridiasis, Types::Nil.optional + attribute :bungey, Types::Nil.optional + attribute :catharticalness, Types::Double.optional + attribute :ceroxyle, Types::Nil.optional + attribute :chirotherium, Types::Integer.optional + attribute :chorology, Types::Nil.optional + attribute :disdiapason, Types::String.optional + attribute :enmarble, Types::Nil.optional + attribute :epeira, Types::Nil.optional + attribute :eurylaimi, Types::Nil.optional + attribute :germination, Types::Nil.optional + attribute :hallelujah, Types::Nil.optional + attribute :homocerc, Types::Bool.optional + attribute :lev, Types::Nil.optional + attribute :mouthing, Types::Nil.optional + attribute :nonbookish, Types::Nil.optional + attribute :philliloo, Types::Nil.optional + attribute :planetal, Types::Nil.optional + attribute :poney, Types::Nil.optional + attribute :punctualist, Types::Nil.optional + attribute :returnlessly, Types::Nil.optional + attribute :skelder, Types::Nil.optional + attribute :windwaywardly, Types::Nil.optional + attribute :yuman, Types::Nil.optional + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + alfiona: d["alfiona"], + ascaridiasis: d["ascaridiasis"], + bungey: d["bungey"], + catharticalness: d["catharticalness"], + ceroxyle: d["ceroxyle"], + chirotherium: d["Chirotherium"], + chorology: d["chorology"], + disdiapason: d["disdiapason"], + enmarble: d["enmarble"], + epeira: d["Epeira"], + eurylaimi: d["Eurylaimi"], + germination: d["germination"], + hallelujah: d["hallelujah"], + homocerc: d["homocerc"], + lev: d["lev"], + mouthing: d["mouthing"], + nonbookish: d["nonbookish"], + philliloo: d["philliloo"], + planetal: d["planetal"], + poney: d["poney"], + punctualist: d["punctualist"], + returnlessly: d["returnlessly"], + skelder: d["skelder"], + windwaywardly: d["windwaywardly"], + yuman: d["Yuman"], + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class TruantcyElement < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :truantcy_class, TruantcyClass.optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, truantcy_class: nil) + end + begin + value = TruantcyClass.from_dynamic!(d) + if schema[:truantcy_class].right.valid? value + return new(truantcy_class: value, bool: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif truantcy_class != nil + truantcy_class.to_dynamic + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Unbeginning < Dry::Struct + attribute :integer_map, Types::Hash.meta(of: Types::Integer).optional + attribute :null_array, Types.Array(Types::Nil).optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + begin + value = Types::Hash[d].map { |k, v| [k, Types::Integer[v]] }.to_h + if schema[:integer_map].right.valid? value + return new(integer_map: value, null_array: nil, string: nil) + end + rescue + end + if schema[:null_array].right.valid? d + return new(null_array: d, integer_map: nil, string: nil) + end + if schema[:string].right.valid? d + return new(string: d, null_array: nil, integer_map: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer_map != nil + integer_map + elsif null_array != nil + null_array + elsif string != nil + string + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Undesirability < Dry::Struct + attribute :integer_array, Types.Array(Types::Integer).optional + attribute :integer_map, Types::Hash.meta(of: Types::Integer).optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + if schema[:integer_array].right.valid? d + return new(integer_array: d, integer_map: nil, string: nil) + end + begin + value = Types::Hash[d].map { |k, v| [k, Types::Integer[v]] }.to_h + if schema[:integer_map].right.valid? value + return new(integer_map: value, integer_array: nil, string: nil) + end + rescue + end + if schema[:string].right.valid? d + return new(string: d, integer_array: nil, integer_map: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer_array != nil + integer_array + elsif integer_map != nil + integer_map + elsif string != nil + string + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Unerasing < Dry::Struct + attribute :integer, Types::Integer.optional + attribute :integer_map, Types::Hash.meta(of: Types::Integer).optional + attribute :null_array, Types.Array(Types::Nil).optional + + def self.from_dynamic!(d) + if schema[:integer].right.valid? d + return new(integer: d, null_array: nil, integer_map: nil) + end + begin + value = Types::Hash[d].map { |k, v| [k, Types::Integer[v]] }.to_h + if schema[:integer_map].right.valid? value + return new(integer_map: value, null_array: nil, integer: nil) + end + rescue + end + if schema[:null_array].right.valid? d + return new(null_array: d, integer: nil, integer_map: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer != nil + integer + elsif integer_map != nil + integer_map + elsif null_array != nil + null_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Unguentarium < Dry::Struct + attribute :integer, Types::Integer.optional + attribute :null, Types::Nil.optional + attribute :null_array, Types.Array(Types::Nil).optional + + def self.from_dynamic!(d) + if schema[:integer].right.valid? d + return new(integer: d, null_array: nil, null: nil) + end + if schema[:null].right.valid? d + return new(null: d, null_array: nil, integer: nil) + end + if schema[:null_array].right.valid? d + return new(null_array: d, integer: nil, null: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer != nil + integer + elsif null_array != nil + null_array + else + nil + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class UnimpeachablyClass < Dry::Struct + attribute :acerin, Types::Integer.optional + attribute :bobadil, Types::Integer.optional + attribute :catharticalness, Types::Double.optional + attribute :chirotherium, Types::Integer.optional + attribute :chlorophylligenous, Types::Integer.optional + attribute :conversational, Types::Integer.optional + attribute :demiowl, Types::Integer.optional + attribute :disdiapason, Types::String.optional + attribute :ectorhinal, Types::Integer.optional + attribute :gamblesomeness, Types::Integer.optional + attribute :homocerc, Types::Bool.optional + attribute :irrorate, Types::Integer.optional + attribute :kindergartening, Types::Integer.optional + attribute :lateritic, Types::Integer.optional + attribute :mespil, Types::Integer.optional + attribute :misconfiguration, Types::Integer.optional + attribute :nonbookish, Types::Nil.optional + attribute :planometry, Types::Integer.optional + attribute :quiina, Types::Integer.optional + attribute :robert, Types::Integer.optional + attribute :rot, Types::Integer.optional + attribute :subcinctorium, Types::Integer.optional + attribute :tussocker, Types::Integer.optional + attribute :ultraproud, Types::Integer.optional + attribute :unsuggestedness, Types::Integer.optional + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + acerin: d["acerin"], + bobadil: d["Bobadil"], + catharticalness: d["catharticalness"], + chirotherium: d["Chirotherium"], + chlorophylligenous: d["chlorophylligenous"], + conversational: d["conversational"], + demiowl: d["demiowl"], + disdiapason: d["disdiapason"], + ectorhinal: d["ectorhinal"], + gamblesomeness: d["gamblesomeness"], + homocerc: d["homocerc"], + irrorate: d["irrorate"], + kindergartening: d["kindergartening"], + lateritic: d["lateritic"], + mespil: d["mespil"], + misconfiguration: d["misconfiguration"], + nonbookish: d["nonbookish"], + planometry: d["planometry"], + quiina: d["Quiina"], + robert: d["Robert"], + rot: d["rot"], + subcinctorium: d["subcinctorium"], + tussocker: d["tussocker"], + ultraproud: d["ultraproud"], + unsuggestedness: d["unsuggestedness"], + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class UnimpeachablyElement < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :unimpeachably_class, UnimpeachablyClass.optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, unimpeachably_class: nil) + end + begin + value = UnimpeachablyClass.from_dynamic!(d) + if schema[:unimpeachably_class].right.valid? value + return new(unimpeachably_class: value, bool: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif unimpeachably_class != nil + unimpeachably_class.to_dynamic + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Unmortgaged < Dry::Struct + attribute :double, Types::Double.optional + attribute :integer_map, Types::Hash.meta(of: Types::Integer).optional + attribute :null, Types::Nil.optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, integer_map: nil, null: nil) + end + begin + value = Types::Hash[d].map { |k, v| [k, Types::Integer[v]] }.to_h + if schema[:integer_map].right.valid? value + return new(integer_map: value, double: nil, null: nil) + end + rescue + end + if schema[:null].right.valid? d + return new(null: d, double: nil, integer_map: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif integer_map != nil + integer_map + else + nil + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Unobstructed < Dry::Struct + attribute :integer, Types::Integer.optional + attribute :null, Types::Nil.optional + attribute :quebrachine_class, QuebrachineClass.optional + + def self.from_dynamic!(d) + if schema[:integer].right.valid? d + return new(integer: d, quebrachine_class: nil, null: nil) + end + if schema[:null].right.valid? d + return new(null: d, quebrachine_class: nil, integer: nil) + end + begin + value = QuebrachineClass.from_dynamic!(d) + if schema[:quebrachine_class].right.valid? value + return new(quebrachine_class: value, integer: nil, null: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer != nil + integer + elsif quebrachine_class != nil + quebrachine_class.to_dynamic + else + nil + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Unreceptivity < Dry::Struct + attribute :integer, Types::Integer.optional + attribute :null_array, Types.Array(Types::Nil).optional + attribute :string, Types::String.optional + + def self.from_dynamic!(d) + if schema[:integer].right.valid? d + return new(integer: d, null_array: nil, string: nil) + end + if schema[:null_array].right.valid? d + return new(null_array: d, integer: nil, string: nil) + end + if schema[:string].right.valid? d + return new(string: d, null_array: nil, integer: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if integer != nil + integer + elsif null_array != nil + null_array + elsif string != nil + string + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Unsatisfactoriness < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :integer, Types::Integer.optional + attribute :integer_array, Types.Array(Types::Integer).optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, integer_array: nil, integer: nil) + end + if schema[:integer].right.valid? d + return new(integer: d, integer_array: nil, bool: nil) + end + if schema[:integer_array].right.valid? d + return new(integer_array: d, bool: nil, integer: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif integer != nil + integer + elsif integer_array != nil + integer_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class UnstressedClass < Dry::Struct + attribute :alain, Types::Nil + attribute :amphirhina, Types::Nil + attribute :antimachinery, Types::Nil + attribute :coldish, Types::Nil + attribute :crantara, Types::Nil + attribute :distinguishing, Types::Nil + attribute :elytroposis, Types::Nil + attribute :gentianwort, Types::Nil + attribute :heliosis, Types::Nil + attribute :instrumental, Types::Nil + attribute :introinflection, Types::Nil + attribute :kala, Types::Nil + attribute :lincolnian, Types::Nil + attribute :metad, Types::Nil + attribute :sarcophilus, Types::Nil + attribute :swingingly, Types::Nil + attribute :unconformity, Types::Nil + attribute :undecreed, Types::Nil + attribute :venerable, Types::Nil + attribute :vowellessness, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + alain: d.fetch("Alain"), + amphirhina: d.fetch("Amphirhina"), + antimachinery: d.fetch("antimachinery"), + coldish: d.fetch("coldish"), + crantara: d.fetch("crantara"), + distinguishing: d.fetch("distinguishing"), + elytroposis: d.fetch("elytroposis"), + gentianwort: d.fetch("gentianwort"), + heliosis: d.fetch("heliosis"), + instrumental: d.fetch("instrumental"), + introinflection: d.fetch("introinflection"), + kala: d.fetch("kala"), + lincolnian: d.fetch("Lincolnian"), + metad: d.fetch("metad"), + sarcophilus: d.fetch("Sarcophilus"), + swingingly: d.fetch("swingingly"), + unconformity: d.fetch("unconformity"), + undecreed: d.fetch("undecreed"), + venerable: d.fetch("venerable"), + vowellessness: d.fetch("vowellessness"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class UnstressedElement < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :string, Types::String.optional + attribute :unstressed_class, UnstressedClass.optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, unstressed_class: nil, string: nil) + end + if schema[:string].right.valid? d + return new(string: d, bool: nil, unstressed_class: nil) + end + begin + value = UnstressedClass.from_dynamic!(d) + if schema[:unstressed_class].right.valid? value + return new(unstressed_class: value, bool: nil, string: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif string != nil + string + elsif unstressed_class != nil + unstressed_class.to_dynamic + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Untasked < Dry::Struct + attribute :double, Types::Double.optional + attribute :integer_map, Types::Hash.meta(of: Types::Integer).optional + attribute :null_array, Types.Array(Types::Nil).optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, null_array: nil, integer_map: nil) + end + begin + value = Types::Hash[d].map { |k, v| [k, Types::Integer[v]] }.to_h + if schema[:integer_map].right.valid? value + return new(integer_map: value, null_array: nil, double: nil) + end + rescue + end + if schema[:null_array].right.valid? d + return new(null_array: d, double: nil, integer_map: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif integer_map != nil + integer_map + elsif null_array != nil + null_array + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Unvarying < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :double, Types::Double.optional + attribute :integer_map, Types::Hash.meta(of: Types::Integer).optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, double: nil, integer_map: nil) + end + if schema[:double].right.valid? d + return new(double: d, bool: nil, integer_map: nil) + end + begin + value = Types::Hash[d].map { |k, v| [k, Types::Integer[v]] }.to_h + if schema[:integer_map].right.valid? value + return new(integer_map: value, bool: nil, double: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif double != nil + double + elsif integer_map != nil + integer_map + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Vehemently < Dry::Struct + attribute :bool, Types::Bool.optional + attribute :null, Types::Nil.optional + attribute :null_array, Types.Array(Types::Nil).optional + + def self.from_dynamic!(d) + if schema[:bool].right.valid? d + return new(bool: d, null_array: nil, null: nil) + end + if schema[:null].right.valid? d + return new(null: d, null_array: nil, bool: nil) + end + if schema[:null_array].right.valid? d + return new(null_array: d, bool: nil, null: nil) + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if bool != nil + bool + elsif null_array != nil + null_array + else + nil + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class Whitepot < Dry::Struct + attribute :double, Types::Double.optional + attribute :quebrachine_class, QuebrachineClass.optional + + def self.from_dynamic!(d) + if schema[:double].right.valid? d + return new(double: d, quebrachine_class: nil) + end + begin + value = QuebrachineClass.from_dynamic!(d) + if schema[:quebrachine_class].right.valid? value + return new(quebrachine_class: value, double: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if double != nil + double + elsif quebrachine_class != nil + quebrachine_class.to_dynamic + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class WrothyClass < Dry::Struct + attribute :aeschynanthus, Types::Nil + attribute :aquiferous, Types::Nil + attribute :cheapener, Types::Nil + attribute :enumeration, Types::Nil + attribute :ephesine, Types::Nil + attribute :escadrille, Types::Nil + attribute :estrous, Types::Nil + attribute :interestedly, Types::Nil + attribute :katakinetomer, Types::Nil + attribute :mortification, Types::Nil + attribute :morula, Types::Nil + attribute :orthosymmetrical, Types::Nil + attribute :overbark, Types::Nil + attribute :politist, Types::Nil + attribute :qualified, Types::Nil + attribute :sphenomalar, Types::Nil + attribute :throatful, Types::Nil + attribute :transhumance, Types::Nil + attribute :triandrian, Types::Nil + attribute :unbooked, Types::Nil + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + aeschynanthus: d.fetch("Aeschynanthus"), + aquiferous: d.fetch("aquiferous"), + cheapener: d.fetch("cheapener"), + enumeration: d.fetch("enumeration"), + ephesine: d.fetch("Ephesine"), + escadrille: d.fetch("escadrille"), + estrous: d.fetch("estrous"), + interestedly: d.fetch("interestedly"), + katakinetomer: d.fetch("katakinetomer"), + mortification: d.fetch("mortification"), + morula: d.fetch("morula"), + orthosymmetrical: d.fetch("orthosymmetrical"), + overbark: d.fetch("overbark"), + politist: d.fetch("politist"), + qualified: d.fetch("qualified"), + sphenomalar: d.fetch("sphenomalar"), + throatful: d.fetch("throatful"), + transhumance: d.fetch("transhumance"), + triandrian: d.fetch("triandrian"), + unbooked: d.fetch("unbooked"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "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, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class WrothyElement < Dry::Struct + attribute :null_array, Types.Array(Types::Nil).optional + attribute :wrothy_class, WrothyClass.optional + + def self.from_dynamic!(d) + if schema[:null_array].right.valid? d + return new(null_array: d, wrothy_class: nil) + end + begin + value = WrothyClass.from_dynamic!(d) + if schema[:wrothy_class].right.valid? value + return new(wrothy_class: value, null_array: nil) + end + rescue + end + raise "Invalid union" + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + if null_array != nil + null_array + elsif wrothy_class != nil + wrothy_class.to_dynamic + end + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class TopLevel < Dry::Struct + attribute :protrusive, Types.Array(Types.Instance(Protrusive)) + attribute :pulpitism, Types.Array(Types.Instance(PulpitismElement)) + attribute :pyodermia, Types.Array(Types.Instance(PyodermiaElement)) + attribute :quebrachine, Types.Array(Types.Instance(QuebrachineElement)) + attribute :querier, Types.Array(Types.Instance(Querier)) + attribute :rebarbative, Types.Array(Types.Instance(Rebarbative)) + attribute :reimagine, Types.Array(Reimagine) + attribute :ressaut, Ressaut + attribute :retrocervical, Types.Array(Types.Instance(Retrocervical)) + attribute :revert, Types.Array(Types.Instance(Revert)) + attribute :rewrite, Types.Array(Types.Instance(RewriteElement)) + attribute :saccoderm, Types.Array(Types.Instance(Saccoderm)) + attribute :santir, Types.Array(Types.Instance(SantirElement)) + attribute :saprophilous, Types.Array(Types.Instance(Saprophilous)) + attribute :saxten, Types.Array(Types.Instance(SaxtenElement)) + attribute :scatty, Types.Array(Scatty.optional) + attribute :scoffer, Types.Array(Types.Instance(Scoffer)) + attribute :scrampum, Types.Array(Types.Instance(Scrampum)) + attribute :semantic, Types::Double + attribute :serpentinic, Types.Array(Types.Instance(Serpentinic)) + attribute :shadowable, Types.Array(Types.Instance(Shadowable)) + attribute :sistering, Types.Array(Types.Instance(SisteringElement)) + attribute :staghunting, Types.Array(Staghunting) + attribute :stagmometer, Types.Array(Types.Instance(Stagmometer)) + attribute :stimulability, Types.Array(Types.Instance(Stimulability)) + attribute :strangleable, Types.Array(Types.Instance(Strangleable)) + attribute :strenuosity, Types.Array(Types.Instance(StrenuosityElement)) + attribute :tabaxir, Types.Array(Types.Instance(Tabaxir)) + attribute :talpiform, Types.Array(Types.Instance(Talpiform)) + attribute :thwack, Types.Array(Types.Instance(Thwack)) + attribute :to, Types.Array(Types::Double.optional) + attribute :tortricine, Types.Array(Types.Instance(Tortricine)) + attribute :truantcy, Types.Array(Types.Instance(TruantcyElement)) + attribute :turgesce, Types.Array(Types::String) + attribute :unbeginning, Types.Array(Types.Instance(Unbeginning)) + attribute :underdunged, Types.Array(Types::Double) + attribute :undesirability, Types.Array(Types.Instance(Undesirability)) + attribute :unerasing, Types.Array(Types.Instance(Unerasing)) + attribute :unguentarium, Types.Array(Types.Instance(Unguentarium)) + attribute :unimpeachably, Types.Array(Types.Instance(UnimpeachablyElement)) + attribute :unmortgaged, Types.Array(Types.Instance(Unmortgaged)) + attribute :unobstructed, Types.Array(Types.Instance(Unobstructed)) + attribute :unreceptivity, Types.Array(Types.Instance(Unreceptivity)) + attribute :unsatisfactoriness, Types.Array(Types.Instance(Unsatisfactoriness)) + attribute :unsecurity, Types.Array(Types::Integer) + attribute :unstressed, Types.Array(Types.Instance(UnstressedElement)) + attribute :untasked, Types.Array(Types.Instance(Untasked)) + attribute :unvarying, Types.Array(Types.Instance(Unvarying)) + attribute :vehemently, Types.Array(Types.Instance(Vehemently)) + attribute :warriorship, Types::Hash.meta(of: Types::Bool) + attribute :whitepot, Types.Array(Types.Instance(Whitepot)) + attribute :wrothy, Types.Array(Types.Instance(WrothyElement)) + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + protrusive: d.fetch("protrusive").map { |x| Protrusive.from_dynamic!(x) }, + pulpitism: d.fetch("pulpitism").map { |x| PulpitismElement.from_dynamic!(x) }, + pyodermia: d.fetch("pyodermia").map { |x| PyodermiaElement.from_dynamic!(x) }, + quebrachine: d.fetch("quebrachine").map { |x| QuebrachineElement.from_dynamic!(x) }, + querier: d.fetch("querier").map { |x| Querier.from_dynamic!(x) }, + rebarbative: d.fetch("rebarbative").map { |x| Rebarbative.from_dynamic!(x) }, + reimagine: d.fetch("reimagine").map { |x| Reimagine.from_dynamic!(x) }, + ressaut: Ressaut.from_dynamic!(d.fetch("ressaut")), + retrocervical: d.fetch("retrocervical").map { |x| Retrocervical.from_dynamic!(x) }, + revert: d.fetch("revert").map { |x| Revert.from_dynamic!(x) }, + rewrite: d.fetch("rewrite").map { |x| RewriteElement.from_dynamic!(x) }, + saccoderm: d.fetch("saccoderm").map { |x| Saccoderm.from_dynamic!(x) }, + santir: d.fetch("santir").map { |x| SantirElement.from_dynamic!(x) }, + saprophilous: d.fetch("saprophilous").map { |x| Saprophilous.from_dynamic!(x) }, + saxten: d.fetch("saxten").map { |x| SaxtenElement.from_dynamic!(x) }, + scatty: d.fetch("scatty").map { |x| x ? Scatty.from_dynamic!(x) : nil }, + scoffer: d.fetch("scoffer").map { |x| Scoffer.from_dynamic!(x) }, + scrampum: d.fetch("scrampum").map { |x| Scrampum.from_dynamic!(x) }, + semantic: d.fetch("semantic"), + serpentinic: d.fetch("serpentinic").map { |x| Serpentinic.from_dynamic!(x) }, + shadowable: d.fetch("shadowable").map { |x| Shadowable.from_dynamic!(x) }, + sistering: d.fetch("sistering").map { |x| SisteringElement.from_dynamic!(x) }, + staghunting: d.fetch("staghunting").map { |x| Staghunting.from_dynamic!(x) }, + stagmometer: d.fetch("stagmometer").map { |x| Stagmometer.from_dynamic!(x) }, + stimulability: d.fetch("stimulability").map { |x| Stimulability.from_dynamic!(x) }, + strangleable: d.fetch("strangleable").map { |x| Strangleable.from_dynamic!(x) }, + strenuosity: d.fetch("strenuosity").map { |x| StrenuosityElement.from_dynamic!(x) }, + tabaxir: d.fetch("tabaxir").map { |x| Tabaxir.from_dynamic!(x) }, + talpiform: d.fetch("talpiform").map { |x| Talpiform.from_dynamic!(x) }, + thwack: d.fetch("thwack").map { |x| Thwack.from_dynamic!(x) }, + to: d.fetch("to"), + tortricine: d.fetch("tortricine").map { |x| Tortricine.from_dynamic!(x) }, + truantcy: d.fetch("truantcy").map { |x| TruantcyElement.from_dynamic!(x) }, + turgesce: d.fetch("turgesce"), + unbeginning: d.fetch("unbeginning").map { |x| Unbeginning.from_dynamic!(x) }, + underdunged: d.fetch("underdunged"), + undesirability: d.fetch("undesirability").map { |x| Undesirability.from_dynamic!(x) }, + unerasing: d.fetch("unerasing").map { |x| Unerasing.from_dynamic!(x) }, + unguentarium: d.fetch("unguentarium").map { |x| Unguentarium.from_dynamic!(x) }, + unimpeachably: d.fetch("unimpeachably").map { |x| UnimpeachablyElement.from_dynamic!(x) }, + unmortgaged: d.fetch("unmortgaged").map { |x| Unmortgaged.from_dynamic!(x) }, + unobstructed: d.fetch("unobstructed").map { |x| Unobstructed.from_dynamic!(x) }, + unreceptivity: d.fetch("unreceptivity").map { |x| Unreceptivity.from_dynamic!(x) }, + unsatisfactoriness: d.fetch("unsatisfactoriness").map { |x| Unsatisfactoriness.from_dynamic!(x) }, + unsecurity: d.fetch("unsecurity"), + unstressed: d.fetch("unstressed").map { |x| UnstressedElement.from_dynamic!(x) }, + untasked: d.fetch("untasked").map { |x| Untasked.from_dynamic!(x) }, + unvarying: d.fetch("unvarying").map { |x| Unvarying.from_dynamic!(x) }, + vehemently: d.fetch("vehemently").map { |x| Vehemently.from_dynamic!(x) }, + warriorship: Types::Hash[d.fetch("warriorship")].map { |k, v| [k, Types::Bool[v]] }.to_h, + whitepot: d.fetch("whitepot").map { |x| Whitepot.from_dynamic!(x) }, + wrothy: d.fetch("wrothy").map { |x| WrothyElement.from_dynamic!(x) }, + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "protrusive" => protrusive.map { |x| x.to_dynamic }, + "pulpitism" => pulpitism.map { |x| x.to_dynamic }, + "pyodermia" => pyodermia.map { |x| x.to_dynamic }, + "quebrachine" => quebrachine.map { |x| x.to_dynamic }, + "querier" => querier.map { |x| x.to_dynamic }, + "rebarbative" => rebarbative.map { |x| x.to_dynamic }, + "reimagine" => reimagine.map { |x| x.to_dynamic }, + "ressaut" => ressaut.to_dynamic, + "retrocervical" => retrocervical.map { |x| x.to_dynamic }, + "revert" => revert.map { |x| x.to_dynamic }, + "rewrite" => rewrite.map { |x| x.to_dynamic }, + "saccoderm" => saccoderm.map { |x| x.to_dynamic }, + "santir" => santir.map { |x| x.to_dynamic }, + "saprophilous" => saprophilous.map { |x| x.to_dynamic }, + "saxten" => saxten.map { |x| x.to_dynamic }, + "scatty" => scatty.map { |x| x&.to_dynamic }, + "scoffer" => scoffer.map { |x| x.to_dynamic }, + "scrampum" => scrampum.map { |x| x.to_dynamic }, + "semantic" => semantic, + "serpentinic" => serpentinic.map { |x| x.to_dynamic }, + "shadowable" => shadowable.map { |x| x.to_dynamic }, + "sistering" => sistering.map { |x| x.to_dynamic }, + "staghunting" => staghunting.map { |x| x.to_dynamic }, + "stagmometer" => stagmometer.map { |x| x.to_dynamic }, + "stimulability" => stimulability.map { |x| x.to_dynamic }, + "strangleable" => strangleable.map { |x| x.to_dynamic }, + "strenuosity" => strenuosity.map { |x| x.to_dynamic }, + "tabaxir" => tabaxir.map { |x| x.to_dynamic }, + "talpiform" => talpiform.map { |x| x.to_dynamic }, + "thwack" => thwack.map { |x| x.to_dynamic }, + "to" => to, + "tortricine" => tortricine.map { |x| x.to_dynamic }, + "truantcy" => truantcy.map { |x| x.to_dynamic }, + "turgesce" => turgesce, + "unbeginning" => unbeginning.map { |x| x.to_dynamic }, + "underdunged" => underdunged, + "undesirability" => undesirability.map { |x| x.to_dynamic }, + "unerasing" => unerasing.map { |x| x.to_dynamic }, + "unguentarium" => unguentarium.map { |x| x.to_dynamic }, + "unimpeachably" => unimpeachably.map { |x| x.to_dynamic }, + "unmortgaged" => unmortgaged.map { |x| x.to_dynamic }, + "unobstructed" => unobstructed.map { |x| x.to_dynamic }, + "unreceptivity" => unreceptivity.map { |x| x.to_dynamic }, + "unsatisfactoriness" => unsatisfactoriness.map { |x| x.to_dynamic }, + "unsecurity" => unsecurity, + "unstressed" => unstressed.map { |x| x.to_dynamic }, + "untasked" => untasked.map { |x| x.to_dynamic }, + "unvarying" => unvarying.map { |x| x.to_dynamic }, + "vehemently" => vehemently.map { |x| x.to_dynamic }, + "warriorship" => warriorship, + "whitepot" => whitepot.map { |x| x.to_dynamic }, + "wrothy" => wrothy.map { |x| x.to_dynamic }, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end diff --git a/base/schema-kotlin-jackson/test/inputs/schema/class-map-union.schema/default/TopLevel.kt b/head/schema-kotlin-jackson/test/inputs/schema/class-map-union.schema/default/TopLevel.kt index 23e8ee7..caec38c 100644 --- a/base/schema-kotlin-jackson/test/inputs/schema/class-map-union.schema/default/TopLevel.kt +++ b/head/schema-kotlin-jackson/test/inputs/schema/class-map-union.schema/default/TopLevel.kt @@ -55,11 +55,11 @@ sealed class UnionValue { companion object { fun fromJson(jn: JsonNode): UnionValue = when (jn) { - is BooleanNode -> BoolValue(mapper.treeToValue(jn)) - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is TextNode -> StringValue(mapper.treeToValue(jn)) - is ObjectNode -> UnionClassValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is BooleanNode -> BoolValue(mapper.treeToValue(jn)) + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is TextNode -> StringValue(mapper.treeToValue(jn)) + is ObjectNode -> UnionClassValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } diff --git a/base/schema-kotlin-jackson/test/inputs/schema/class-with-additional.schema/default/TopLevel.kt b/head/schema-kotlin-jackson/test/inputs/schema/class-with-additional.schema/default/TopLevel.kt index de558f1..97bf339 100644 --- a/base/schema-kotlin-jackson/test/inputs/schema/class-with-additional.schema/default/TopLevel.kt +++ b/head/schema-kotlin-jackson/test/inputs/schema/class-with-additional.schema/default/TopLevel.kt @@ -51,9 +51,9 @@ sealed class MapValue { companion object { fun fromJson(jn: JsonNode): MapValue = when (jn) { - is BooleanNode -> BoolValue(mapper.treeToValue(jn)) - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is BooleanNode -> BoolValue(mapper.treeToValue(jn)) + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } diff --git a/base/schema-kotlin-jackson/test/inputs/schema/constructor.schema/default/TopLevel.kt b/head/schema-kotlin-jackson/test/inputs/schema/constructor.schema/default/TopLevel.kt index 7c1c8a4..7847944 100644 --- a/base/schema-kotlin-jackson/test/inputs/schema/constructor.schema/default/TopLevel.kt +++ b/head/schema-kotlin-jackson/test/inputs/schema/constructor.schema/default/TopLevel.kt @@ -51,9 +51,9 @@ sealed class UnionConstructor { companion object { fun fromJson(jn: JsonNode): UnionConstructor = when (jn) { - is ObjectNode -> ConstructorValue(mapper.treeToValue(jn)) - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is ObjectNode -> ConstructorValue(mapper.treeToValue(jn)) + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } diff --git a/base/schema-kotlin-jackson/test/inputs/schema/integer-before-number.schema/default/TopLevel.kt b/head/schema-kotlin-jackson/test/inputs/schema/integer-before-number.schema/default/TopLevel.kt index 36233db..fb9107b 100644 --- a/base/schema-kotlin-jackson/test/inputs/schema/integer-before-number.schema/default/TopLevel.kt +++ b/head/schema-kotlin-jackson/test/inputs/schema/integer-before-number.schema/default/TopLevel.kt @@ -44,9 +44,9 @@ sealed class TopLevel { companion object { fun fromJson(jn: JsonNode): TopLevel = when (jn) { - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is IntNode, is LongNode -> IntegerValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is IntNode, is LongNode -> IntegerValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } diff --git a/base/schema-kotlin-jackson/test/inputs/schema/integer-float-union.schema/default/TopLevel.kt b/head/schema-kotlin-jackson/test/inputs/schema/integer-float-union.schema/default/TopLevel.kt index 9993706..72c3235 100644 --- a/base/schema-kotlin-jackson/test/inputs/schema/integer-float-union.schema/default/TopLevel.kt +++ b/head/schema-kotlin-jackson/test/inputs/schema/integer-float-union.schema/default/TopLevel.kt @@ -52,9 +52,9 @@ sealed class Number { companion object { fun fromJson(jn: JsonNode): Number = when (jn) { - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is IntNode, is LongNode -> IntegerValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is IntNode, is LongNode -> IntegerValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } diff --git a/base/schema-kotlin-jackson/test/inputs/schema/minmaxlength.schema/default/TopLevel.kt b/head/schema-kotlin-jackson/test/inputs/schema/minmaxlength.schema/default/TopLevel.kt index 1bad4ec..3150cc5 100644 --- a/base/schema-kotlin-jackson/test/inputs/schema/minmaxlength.schema/default/TopLevel.kt +++ b/head/schema-kotlin-jackson/test/inputs/schema/minmaxlength.schema/default/TopLevel.kt @@ -73,9 +73,9 @@ sealed class InUnion { companion object { fun fromJson(jn: JsonNode): InUnion = when (jn) { - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is TextNode -> StringValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is TextNode -> StringValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } diff --git a/base/schema-kotlin-jackson/test/inputs/schema/multi-type-enum.schema/default/TopLevel.kt b/head/schema-kotlin-jackson/test/inputs/schema/multi-type-enum.schema/default/TopLevel.kt index fbff16d..4d3ac39 100644 --- a/base/schema-kotlin-jackson/test/inputs/schema/multi-type-enum.schema/default/TopLevel.kt +++ b/head/schema-kotlin-jackson/test/inputs/schema/multi-type-enum.schema/default/TopLevel.kt @@ -57,11 +57,11 @@ sealed class FooUnion { companion object { fun fromJson(jn: JsonNode): FooUnion = when (jn) { - is BooleanNode -> BoolValue(mapper.treeToValue(jn)) - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is TextNode -> EnumValue(mapper.treeToValue(jn)) - is IntNode, is LongNode -> IntegerValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is BooleanNode -> BoolValue(mapper.treeToValue(jn)) + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is TextNode -> EnumValue(mapper.treeToValue(jn)) + is IntNode, is LongNode -> IntegerValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } diff --git a/base/schema-kotlin-jackson/test/inputs/schema/recursive-union-flattening.schema/default/TopLevel.kt b/head/schema-kotlin-jackson/test/inputs/schema/recursive-union-flattening.schema/default/TopLevel.kt index 5af210e..f1e976c 100644 --- a/base/schema-kotlin-jackson/test/inputs/schema/recursive-union-flattening.schema/default/TopLevel.kt +++ b/head/schema-kotlin-jackson/test/inputs/schema/recursive-union-flattening.schema/default/TopLevel.kt @@ -54,14 +54,14 @@ sealed class TopLevel { companion object { fun fromJson(jn: JsonNode): TopLevel = when (jn) { - is ObjectNode -> AnythingMapValue(mapper.treeToValue(jn)) - is BooleanNode -> BoolValue(mapper.treeToValue(jn)) - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is IntNode, is LongNode -> IntegerValue(mapper.treeToValue(jn)) - is TextNode -> StringValue(mapper.treeToValue(jn)) - is ArrayNode -> UnionArrayValue(mapper.treeToValue(jn)) - null -> NullValue() - else -> throw IllegalArgumentException() + is ObjectNode -> AnythingMapValue(mapper.treeToValue(jn)) + is BooleanNode -> BoolValue(mapper.treeToValue(jn)) + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is IntNode, is LongNode -> IntegerValue(mapper.treeToValue(jn)) + is TextNode -> StringValue(mapper.treeToValue(jn)) + is ArrayNode -> UnionArrayValue(mapper.treeToValue(jn)) + null -> NullValue() + else -> throw IllegalArgumentException() } } } @@ -87,14 +87,14 @@ sealed class TopLevelElement { companion object { fun fromJson(jn: JsonNode): TopLevelElement = when (jn) { - is ArrayNode -> AnythingArrayValue(mapper.treeToValue(jn)) - is BooleanNode -> BoolValue(mapper.treeToValue(jn)) - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is IntNode, is LongNode -> IntegerValue(mapper.treeToValue(jn)) - is TextNode -> StringValue(mapper.treeToValue(jn)) - is ObjectNode -> TopLevelClassValue(mapper.treeToValue(jn)) - null -> NullValue() - else -> throw IllegalArgumentException() + is ArrayNode -> AnythingArrayValue(mapper.treeToValue(jn)) + is BooleanNode -> BoolValue(mapper.treeToValue(jn)) + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is IntNode, is LongNode -> IntegerValue(mapper.treeToValue(jn)) + is TextNode -> StringValue(mapper.treeToValue(jn)) + is ObjectNode -> TopLevelClassValue(mapper.treeToValue(jn)) + null -> NullValue() + else -> throw IllegalArgumentException() } } } @@ -128,14 +128,14 @@ sealed class XElement { companion object { fun fromJson(jn: JsonNode): XElement = when (jn) { - is ArrayNode -> AnythingArrayValue(mapper.treeToValue(jn)) - is BooleanNode -> BoolValue(mapper.treeToValue(jn)) - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is IntNode, is LongNode -> IntegerValue(mapper.treeToValue(jn)) - is TextNode -> StringValue(mapper.treeToValue(jn)) - is ObjectNode -> XClassValue(mapper.treeToValue(jn)) - null -> NullValue() - else -> throw IllegalArgumentException() + is ArrayNode -> AnythingArrayValue(mapper.treeToValue(jn)) + is BooleanNode -> BoolValue(mapper.treeToValue(jn)) + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is IntNode, is LongNode -> IntegerValue(mapper.treeToValue(jn)) + is TextNode -> StringValue(mapper.treeToValue(jn)) + is ObjectNode -> XClassValue(mapper.treeToValue(jn)) + null -> NullValue() + else -> throw IllegalArgumentException() } } } @@ -161,14 +161,14 @@ sealed class X { companion object { fun fromJson(jn: JsonNode): X = when (jn) { - is ObjectNode -> AnythingMapValue(mapper.treeToValue(jn)) - is BooleanNode -> BoolValue(mapper.treeToValue(jn)) - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is IntNode, is LongNode -> IntegerValue(mapper.treeToValue(jn)) - is TextNode -> StringValue(mapper.treeToValue(jn)) - is ArrayNode -> UnionArrayValue(mapper.treeToValue(jn)) - null -> NullValue() - else -> throw IllegalArgumentException() + is ObjectNode -> AnythingMapValue(mapper.treeToValue(jn)) + is BooleanNode -> BoolValue(mapper.treeToValue(jn)) + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is IntNode, is LongNode -> IntegerValue(mapper.treeToValue(jn)) + is TextNode -> StringValue(mapper.treeToValue(jn)) + is ArrayNode -> UnionArrayValue(mapper.treeToValue(jn)) + null -> NullValue() + else -> throw IllegalArgumentException() } } } diff --git a/base/schema-kotlin-jackson/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.kt b/head/schema-kotlin-jackson/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.kt index 95676ca..a7747ad 100644 --- a/base/schema-kotlin-jackson/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.kt +++ b/head/schema-kotlin-jackson/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.kt @@ -67,14 +67,14 @@ sealed class Closed { companion object { fun fromJson(jn: JsonNode): Closed = when (jn) { - is ArrayNode -> AnythingArrayValue(mapper.treeToValue(jn)) - is BooleanNode -> BoolValue(mapper.treeToValue(jn)) - is ObjectNode -> ClosedClassValue(mapper.treeToValue(jn)) - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is IntNode, is LongNode -> IntegerValue(mapper.treeToValue(jn)) - is TextNode -> StringValue(mapper.treeToValue(jn)) - null -> NullValue() - else -> throw IllegalArgumentException() + is ArrayNode -> AnythingArrayValue(mapper.treeToValue(jn)) + is BooleanNode -> BoolValue(mapper.treeToValue(jn)) + is ObjectNode -> ClosedClassValue(mapper.treeToValue(jn)) + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is IntNode, is LongNode -> IntegerValue(mapper.treeToValue(jn)) + is TextNode -> StringValue(mapper.treeToValue(jn)) + null -> NullValue() + else -> throw IllegalArgumentException() } } } diff --git a/base/schema-kotlin-jackson/test/inputs/schema/union-int-double.schema/default/TopLevel.kt b/head/schema-kotlin-jackson/test/inputs/schema/union-int-double.schema/default/TopLevel.kt index f9ec4d6..430d7d1 100644 --- a/base/schema-kotlin-jackson/test/inputs/schema/union-int-double.schema/default/TopLevel.kt +++ b/head/schema-kotlin-jackson/test/inputs/schema/union-int-double.schema/default/TopLevel.kt @@ -54,10 +54,10 @@ sealed class Value { companion object { fun fromJson(jn: JsonNode): Value = when (jn) { - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is IntNode, is LongNode -> IntegerValue(mapper.treeToValue(jn)) - is TextNode -> StringValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is IntNode, is LongNode -> IntegerValue(mapper.treeToValue(jn)) + is TextNode -> StringValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } diff --git a/base/schema-kotlin-jackson/test/inputs/schema/vega-lite.schema/default/TopLevel.kt b/head/schema-kotlin-jackson/test/inputs/schema/vega-lite.schema/default/TopLevel.kt index bd9d865..403a8ca 100644 --- a/base/schema-kotlin-jackson/test/inputs/schema/vega-lite.schema/default/TopLevel.kt +++ b/head/schema-kotlin-jackson/test/inputs/schema/vega-lite.schema/default/TopLevel.kt @@ -1026,9 +1026,9 @@ sealed class FontWeightUnion { companion object { fun fromJson(jn: JsonNode): FontWeightUnion = when (jn) { - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is TextNode -> EnumValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is TextNode -> EnumValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } @@ -1405,9 +1405,9 @@ sealed class Label { companion object { fun fromJson(jn: JsonNode): Label = when (jn) { - is BooleanNode -> BoolValue(mapper.treeToValue(jn)) - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is BooleanNode -> BoolValue(mapper.treeToValue(jn)) + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } @@ -1459,9 +1459,9 @@ sealed class TitleFontWeight { companion object { fun fromJson(jn: JsonNode): TitleFontWeight = when (jn) { - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is TextNode -> StringValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is TextNode -> StringValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } @@ -2248,9 +2248,9 @@ sealed class Padding { companion object { fun fromJson(jn: JsonNode): Padding = when (jn) { - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is ObjectNode -> PaddingClassValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is ObjectNode -> PaddingClassValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } @@ -4047,11 +4047,11 @@ sealed class ValuesValue { companion object { fun fromJson(jn: JsonNode): ValuesValue = when (jn) { - is ObjectNode -> AnythingMapValue(mapper.treeToValue(jn)) - is BooleanNode -> BoolValue(mapper.treeToValue(jn)) - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is TextNode -> StringValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is ObjectNode -> AnythingMapValue(mapper.treeToValue(jn)) + is BooleanNode -> BoolValue(mapper.treeToValue(jn)) + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is TextNode -> StringValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } @@ -4597,11 +4597,11 @@ sealed class Equal { companion object { fun fromJson(jn: JsonNode): Equal = when (jn) { - is BooleanNode -> BoolValue(mapper.treeToValue(jn)) - is ObjectNode -> DateTimeValue(mapper.treeToValue(jn)) - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is TextNode -> StringValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is BooleanNode -> BoolValue(mapper.treeToValue(jn)) + is ObjectNode -> DateTimeValue(mapper.treeToValue(jn)) + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is TextNode -> StringValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } @@ -4689,9 +4689,9 @@ sealed class Day { companion object { fun fromJson(jn: JsonNode): Day = when (jn) { - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is TextNode -> StringValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is TextNode -> StringValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } @@ -4712,9 +4712,9 @@ sealed class Month { companion object { fun fromJson(jn: JsonNode): Month = when (jn) { - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is TextNode -> StringValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is TextNode -> StringValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } @@ -4732,10 +4732,10 @@ sealed class RangeElement { companion object { fun fromJson(jn: JsonNode): RangeElement = when (jn) { - is ObjectNode -> DateTimeValue(mapper.treeToValue(jn)) - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - null -> NullValue() - else -> throw IllegalArgumentException() + is ObjectNode -> DateTimeValue(mapper.treeToValue(jn)) + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + null -> NullValue() + else -> throw IllegalArgumentException() } } } @@ -4868,10 +4868,10 @@ sealed class ConditionalValueDefValue { companion object { fun fromJson(jn: JsonNode): ConditionalValueDefValue = when (jn) { - is BooleanNode -> BoolValue(mapper.treeToValue(jn)) - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is TextNode -> StringValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is BooleanNode -> BoolValue(mapper.treeToValue(jn)) + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is TextNode -> StringValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } @@ -5125,10 +5125,10 @@ sealed class LegendValue { companion object { fun fromJson(jn: JsonNode): LegendValue = when (jn) { - is ObjectNode -> DateTimeValue(mapper.treeToValue(jn)) - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is TextNode -> StringValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is ObjectNode -> DateTimeValue(mapper.treeToValue(jn)) + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is TextNode -> StringValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } @@ -5518,11 +5518,11 @@ sealed class NiceUnion { companion object { fun fromJson(jn: JsonNode): NiceUnion = when (jn) { - is BooleanNode -> BoolValue(mapper.treeToValue(jn)) - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - is TextNode -> EnumValue(mapper.treeToValue(jn)) - is ObjectNode -> NiceClassValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is BooleanNode -> BoolValue(mapper.treeToValue(jn)) + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + is TextNode -> EnumValue(mapper.treeToValue(jn)) + is ObjectNode -> NiceClassValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } } @@ -6695,9 +6695,9 @@ sealed class AxisValue { companion object { fun fromJson(jn: JsonNode): AxisValue = when (jn) { - is ObjectNode -> DateTimeValue(mapper.treeToValue(jn)) - is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) - else -> throw IllegalArgumentException() + is ObjectNode -> DateTimeValue(mapper.treeToValue(jn)) + is IntNode, is LongNode, is DoubleNode -> DoubleValue(mapper.treeToValue(jn)) + else -> throw IllegalArgumentException() } } }