ddb_ruby 0.0.1 → 0.0.2

data/lib/ddb_ruby/structs.rb

@@ -0,0 +1,3519 @@
+# 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:
+#
+#   character = Character.from_json! "{…}"
+#   puts character.optional_class_features.first
+#
+# If from_json! succeeds, the value returned matches the schema.
+
+# require 'json'
+# require 'dry-types'
+# require 'dry-struct'
+
+module DdbRuby
+  module Types
+    include Dry.Types(default: :nominal)
+
+    Integer                = Coercible::Integer
+    Bool                   = Types::Params::Bool
+    Hash                   = Coercible::Hash
+    String                 = Coercible::String
+    Double                 = Coercible::Float | Coercible::Integer
+    Restriction            = Coercible::String.enum("Concentration", "")
+    EntityType             = Coercible::String.enum("class-feature")
+    ContainerDefinitionKey = Coercible::String.enum("1581111423:53552888")
+    FilterType             = Coercible::String.enum("Armor", "Other Gear", "Potion", "Weapon")
+    Rarity                 = Coercible::String.enum("Common", "Rare", "Uncommon")
+  end
+
+  class Activation < Dry::Struct
+    attribute :activation_time, Types::Integer.optional
+    attribute :activation_type, Types::Integer.optional
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        activation_time: d.fetch("activationTime"),
+        activation_type: d.fetch("activationType"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "activationTime" => activation_time,
+        "activationType" => activation_type,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class ClassLimitedUse < Dry::Struct
+    attribute :limited_use_name,           Types::Nil
+    attribute :stat_modifier_uses_id,      Types::Nil
+    attribute :reset_type,                 Types::Integer
+    attribute :number_used,                Types::Integer
+    attribute :min_number_consumed,        Types::Integer
+    attribute :max_number_consumed,        Types::Integer
+    attribute :max_uses,                   Types::Integer
+    attribute :operator,                   Types::Integer
+    attribute :use_proficiency_bonus,      Types::Bool
+    attribute :proficiency_bonus_operator, Types::Integer
+    attribute :reset_dice,                 Types::Nil
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        limited_use_name:           d.fetch("name"),
+        stat_modifier_uses_id:      d.fetch("statModifierUsesId"),
+        reset_type:                 d.fetch("resetType"),
+        number_used:                d.fetch("numberUsed"),
+        min_number_consumed:        d.fetch("minNumberConsumed"),
+        max_number_consumed:        d.fetch("maxNumberConsumed"),
+        max_uses:                   d.fetch("maxUses"),
+        operator:                   d.fetch("operator"),
+        use_proficiency_bonus:      d.fetch("useProficiencyBonus"),
+        proficiency_bonus_operator: d.fetch("proficiencyBonusOperator"),
+        reset_dice:                 d.fetch("resetDice"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "name"                     => limited_use_name,
+        "statModifierUsesId"       => stat_modifier_uses_id,
+        "resetType"                => reset_type,
+        "numberUsed"               => number_used,
+        "minNumberConsumed"        => min_number_consumed,
+        "maxNumberConsumed"        => max_number_consumed,
+        "maxUses"                  => max_uses,
+        "operator"                 => operator,
+        "useProficiencyBonus"      => use_proficiency_bonus,
+        "proficiencyBonusOperator" => proficiency_bonus_operator,
+        "resetDice"                => reset_dice,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class ClassRange < Dry::Struct
+    attribute :range,                       Types::Nil
+    attribute :long_range,                  Types::Nil
+    attribute :aoe_type,                    Types::Nil
+    attribute :aoe_size,                    Types::Nil
+    attribute :has_aoe_special_description, Types::Bool
+    attribute :minimum_range,               Types::Nil
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        range:                       d.fetch("range"),
+        long_range:                  d.fetch("longRange"),
+        aoe_type:                    d.fetch("aoeType"),
+        aoe_size:                    d.fetch("aoeSize"),
+        has_aoe_special_description: d.fetch("hasAoeSpecialDescription"),
+        minimum_range:               d.fetch("minimumRange"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "range"                    => range,
+        "longRange"                => long_range,
+        "aoeType"                  => aoe_type,
+        "aoeSize"                  => aoe_size,
+        "hasAoeSpecialDescription" => has_aoe_special_description,
+        "minimumRange"             => minimum_range,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class ActionsClass < Dry::Struct
+    attribute :component_id,             Types::Integer
+    attribute :component_type_id,        Types::Integer
+    attribute :id,                       Types::String
+    attribute :entity_type_id,           Types::String
+    attribute :limited_use,              ClassLimitedUse.optional
+    attribute :class_name,               Types::String
+    attribute :description,              Types::String.optional
+    attribute :snippet,                  Types::String
+    attribute :ability_modifier_stat_id, Types::Nil
+    attribute :on_miss_description,      Types::String.optional
+    attribute :save_fail_description,    Types::String.optional
+    attribute :save_success_description, Types::String.optional
+    attribute :save_stat_id,             Types::Nil
+    attribute :fixed_save_dc,            Types::Nil
+    attribute :attack_type_range,        Types::Nil
+    attribute :action_type,              Types::Integer
+    attribute :attack_subtype,           Types::Nil
+    attribute :dice,                     Types::Nil
+    attribute :value,                    Types::Nil
+    attribute :damage_type_id,           Types::Nil
+    attribute :is_martial_arts,          Types::Bool
+    attribute :is_proficient,            Types::Bool
+    attribute :spell_range_type,         Types::Nil
+    attribute :display_as_attack,        Types::Nil
+    attribute :range,                    ClassRange
+    attribute :activation,               Activation
+    attribute :number_of_targets,        Types::Nil
+    attribute :fixed_to_hit,             Types::Nil
+    attribute :ammunition,               Types::Nil
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        component_id:             d.fetch("componentId"),
+        component_type_id:        d.fetch("componentTypeId"),
+        id:                       d.fetch("id"),
+        entity_type_id:           d.fetch("entityTypeId"),
+        limited_use:              d.fetch("limitedUse") ? ClassLimitedUse.from_dynamic!(d.fetch("limitedUse")) : nil,
+        class_name:               d.fetch("name"),
+        description:              d.fetch("description"),
+        snippet:                  d.fetch("snippet"),
+        ability_modifier_stat_id: d.fetch("abilityModifierStatId"),
+        on_miss_description:      d.fetch("onMissDescription"),
+        save_fail_description:    d.fetch("saveFailDescription"),
+        save_success_description: d.fetch("saveSuccessDescription"),
+        save_stat_id:             d.fetch("saveStatId"),
+        fixed_save_dc:            d.fetch("fixedSaveDc"),
+        attack_type_range:        d.fetch("attackTypeRange"),
+        action_type:              d.fetch("actionType"),
+        attack_subtype:           d.fetch("attackSubtype"),
+        dice:                     d.fetch("dice"),
+        value:                    d.fetch("value"),
+        damage_type_id:           d.fetch("damageTypeId"),
+        is_martial_arts:          d.fetch("isMartialArts"),
+        is_proficient:            d.fetch("isProficient"),
+        spell_range_type:         d.fetch("spellRangeType"),
+        display_as_attack:        d.fetch("displayAsAttack"),
+        range:                    ClassRange.from_dynamic!(d.fetch("range")),
+        activation:               Activation.from_dynamic!(d.fetch("activation")),
+        number_of_targets:        d.fetch("numberOfTargets"),
+        fixed_to_hit:             d.fetch("fixedToHit"),
+        ammunition:               d.fetch("ammunition"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "componentId"            => component_id,
+        "componentTypeId"        => component_type_id,
+        "id"                     => id,
+        "entityTypeId"           => entity_type_id,
+        "limitedUse"             => limited_use&.to_dynamic,
+        "name"                   => class_name,
+        "description"            => description,
+        "snippet"                => snippet,
+        "abilityModifierStatId"  => ability_modifier_stat_id,
+        "onMissDescription"      => on_miss_description,
+        "saveFailDescription"    => save_fail_description,
+        "saveSuccessDescription" => save_success_description,
+        "saveStatId"             => save_stat_id,
+        "fixedSaveDc"            => fixed_save_dc,
+        "attackTypeRange"        => attack_type_range,
+        "actionType"             => action_type,
+        "attackSubtype"          => attack_subtype,
+        "dice"                   => dice,
+        "value"                  => value,
+        "damageTypeId"           => damage_type_id,
+        "isMartialArts"          => is_martial_arts,
+        "isProficient"           => is_proficient,
+        "spellRangeType"         => spell_range_type,
+        "displayAsAttack"        => display_as_attack,
+        "range"                  => range.to_dynamic,
+        "activation"             => activation.to_dynamic,
+        "numberOfTargets"        => number_of_targets,
+        "fixedToHit"             => fixed_to_hit,
+        "ammunition"             => ammunition,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class HigherLevelDefinition < Dry::Struct
+    attribute :level,   Types::Integer
+    attribute :type_id, Types::Integer
+    attribute :dice,    Types::Nil
+    attribute :value,   Types::Integer
+    attribute :details, Types::String
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        level:   d.fetch("level"),
+        type_id: d.fetch("typeId"),
+        dice:    d.fetch("dice"),
+        value:   d.fetch("value"),
+        details: d.fetch("details"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "level"   => level,
+        "typeId"  => type_id,
+        "dice"    => dice,
+        "value"   => value,
+        "details" => details,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class AtHigherLevels < Dry::Struct
+    attribute :higher_level_definitions, Types.Array(HigherLevelDefinition)
+    attribute :additional_attacks,       Types.Array(Types::Any)
+    attribute :additional_targets,       Types.Array(Types::Any)
+    attribute :area_of_effect,           Types.Array(Types::Any)
+    attribute :duration,                 Types.Array(Types::Any)
+    attribute :creatures,                Types.Array(Types::Any)
+    attribute :special,                  Types.Array(Types::Any)
+    attribute :points,                   Types.Array(Types::Any)
+    attribute :range,                    Types.Array(Types::Any)
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        higher_level_definitions: d.fetch("higherLevelDefinitions").map { |x| HigherLevelDefinition.from_dynamic!(x) },
+        additional_attacks:       d.fetch("additionalAttacks"),
+        additional_targets:       d.fetch("additionalTargets"),
+        area_of_effect:           d.fetch("areaOfEffect"),
+        duration:                 d.fetch("duration"),
+        creatures:                d.fetch("creatures"),
+        special:                  d.fetch("special"),
+        points:                   d.fetch("points"),
+        range:                    d.fetch("range"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "higherLevelDefinitions" => higher_level_definitions.map { |x| x.to_dynamic },
+        "additionalAttacks"      => additional_attacks,
+        "additionalTargets"      => additional_targets,
+        "areaOfEffect"           => area_of_effect,
+        "duration"               => duration,
+        "creatures"              => creatures,
+        "special"                => special,
+        "points"                 => points,
+        "range"                  => range,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  module Restriction
+    Concentration = "Concentration"
+    Empty         = ""
+  end
+
+  class DefinitionDuration < Dry::Struct
+    attribute :duration_interval, Types::Integer
+    attribute :duration_unit,     Types::String
+    attribute :duration_type,     Types::Restriction
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        duration_interval: d.fetch("durationInterval"),
+        duration_unit:     d.fetch("durationUnit"),
+        duration_type:     d.fetch("durationType"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "durationInterval" => duration_interval,
+        "durationUnit"     => duration_unit,
+        "durationType"     => duration_type,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Die < Dry::Struct
+    attribute :dice_count,      Types::Integer.optional
+    attribute :dice_value,      Types::Integer.optional
+    attribute :dice_multiplier, Types::Integer.optional
+    attribute :fixed_value,     Types::Integer.optional
+    attribute :dice_string,     Types::String.optional
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        dice_count:      d.fetch("diceCount"),
+        dice_value:      d.fetch("diceValue"),
+        dice_multiplier: d.fetch("diceMultiplier"),
+        fixed_value:     d.fetch("fixedValue"),
+        dice_string:     d.fetch("diceString"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "diceCount"      => dice_count,
+        "diceValue"      => dice_value,
+        "diceMultiplier" => dice_multiplier,
+        "fixedValue"     => fixed_value,
+        "diceString"     => dice_string,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class BackgroundDuration < Dry::Struct
+    attribute :duration_interval, Types::Integer
+    attribute :duration_unit,     Types::String
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        duration_interval: d.fetch("durationInterval"),
+        duration_unit:     d.fetch("durationUnit"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "durationInterval" => duration_interval,
+        "durationUnit"     => duration_unit,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class ItemElement < Dry::Struct
+    attribute :fixed_value,             Types::Integer.optional
+    attribute :id,                      Types::String
+    attribute :entity_id,               Types::Integer.optional
+    attribute :entity_type_id,          Types::Integer.optional
+    attribute :background_type,         Types::String
+    attribute :sub_type,                Types::String
+    attribute :dice,                    Die.optional
+    attribute :restriction,             Types::Restriction.optional
+    attribute :stat_id,                 Types::Nil
+    attribute :requires_attunement,     Types::Bool
+    attribute :duration,                BackgroundDuration.optional
+    attribute :friendly_type_name,      Types::String
+    attribute :friendly_subtype_name,   Types::String
+    attribute :is_granted,              Types::Bool
+    attribute :bonus_types,             Types.Array(Types::Any)
+    attribute :value,                   Types::Integer.optional
+    attribute :available_to_multiclass, Types::Bool.optional
+    attribute :modifier_type_id,        Types::Integer
+    attribute :modifier_sub_type_id,    Types::Integer
+    attribute :component_id,            Types::Integer
+    attribute :component_type_id,       Types::Integer
+    attribute :die,                     Die.optional
+    attribute :count,                   Types::Integer.optional
+    attribute :duration_unit,           Types::Nil.optional
+    attribute :use_primary_stat,        Types::Bool.optional
+    attribute :at_higher_levels,        AtHigherLevels.optional
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        fixed_value:             d.fetch("fixedValue"),
+        id:                      d.fetch("id"),
+        entity_id:               d.fetch("entityId"),
+        entity_type_id:          d.fetch("entityTypeId"),
+        background_type:         d.fetch("type"),
+        sub_type:                d.fetch("subType"),
+        dice:                    d.fetch("dice") ? Die.from_dynamic!(d.fetch("dice")) : nil,
+        restriction:             d.fetch("restriction"),
+        stat_id:                 d.fetch("statId"),
+        requires_attunement:     d.fetch("requiresAttunement"),
+        duration:                d.fetch("duration") ? BackgroundDuration.from_dynamic!(d.fetch("duration")) : nil,
+        friendly_type_name:      d.fetch("friendlyTypeName"),
+        friendly_subtype_name:   d.fetch("friendlySubtypeName"),
+        is_granted:              d.fetch("isGranted"),
+        bonus_types:             d.fetch("bonusTypes"),
+        value:                   d.fetch("value"),
+        available_to_multiclass: d.fetch("availableToMulticlass"),
+        modifier_type_id:        d.fetch("modifierTypeId"),
+        modifier_sub_type_id:    d.fetch("modifierSubTypeId"),
+        component_id:            d.fetch("componentId"),
+        component_type_id:       d.fetch("componentTypeId"),
+        die:                     d["die"] ? Die.from_dynamic!(d["die"]) : nil,
+        count:                   d["count"],
+        duration_unit:           d["durationUnit"],
+        use_primary_stat:        d["usePrimaryStat"],
+        at_higher_levels:        d["atHigherLevels"] ? AtHigherLevels.from_dynamic!(d["atHigherLevels"]) : nil,
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "fixedValue"            => fixed_value,
+        "id"                    => id,
+        "entityId"              => entity_id,
+        "entityTypeId"          => entity_type_id,
+        "type"                  => background_type,
+        "subType"               => sub_type,
+        "dice"                  => dice&.to_dynamic,
+        "restriction"           => restriction,
+        "statId"                => stat_id,
+        "requiresAttunement"    => requires_attunement,
+        "duration"              => duration&.to_dynamic,
+        "friendlyTypeName"      => friendly_type_name,
+        "friendlySubtypeName"   => friendly_subtype_name,
+        "isGranted"             => is_granted,
+        "bonusTypes"            => bonus_types,
+        "value"                 => value,
+        "availableToMulticlass" => available_to_multiclass,
+        "modifierTypeId"        => modifier_type_id,
+        "modifierSubTypeId"     => modifier_sub_type_id,
+        "componentId"           => component_id,
+        "componentTypeId"       => component_type_id,
+        "die"                   => die&.to_dynamic,
+        "count"                 => count,
+        "durationUnit"          => duration_unit,
+        "usePrimaryStat"        => use_primary_stat,
+        "atHigherLevels"        => at_higher_levels&.to_dynamic,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class DefinitionRange < Dry::Struct
+    attribute :origin,      Types::String
+    attribute :range_value, Types::Integer
+    attribute :aoe_type,    Types::Nil
+    attribute :aoe_value,   Types::Nil
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        origin:      d.fetch("origin"),
+        range_value: d.fetch("rangeValue"),
+        aoe_type:    d.fetch("aoeType"),
+        aoe_value:   d.fetch("aoeValue"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "origin"     => origin,
+        "rangeValue" => range_value,
+        "aoeType"    => aoe_type,
+        "aoeValue"   => aoe_value,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Source < Dry::Struct
+    attribute :source_id,   Types::Integer
+    attribute :page_number, Types::Integer.optional
+    attribute :source_type, Types::Integer
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        source_id:   d.fetch("sourceId"),
+        page_number: d.fetch("pageNumber"),
+        source_type: d.fetch("sourceType"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "sourceId"   => source_id,
+        "pageNumber" => page_number,
+        "sourceType" => source_type,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class ItemDefinition < Dry::Struct
+    attribute :id,                       Types::Integer
+    attribute :definition_key,           Types::String
+    attribute :definition_name,          Types::String
+    attribute :level,                    Types::Integer
+    attribute :school,                   Types::String
+    attribute :duration,                 DefinitionDuration
+    attribute :activation,               Activation
+    attribute :range,                    DefinitionRange
+    attribute :as_part_of_weapon_attack, Types::Bool
+    attribute :description,              Types::String
+    attribute :snippet,                  Types::String
+    attribute :concentration,            Types::Bool
+    attribute :ritual,                   Types::Bool
+    attribute :range_area,               Types::Nil
+    attribute :damage_effect,            Types::Nil
+    attribute :components,               Types.Array(Types::Integer)
+    attribute :components_description,   Types::String
+    attribute :save_dc_ability_id,       Types::Nil
+    attribute :healing,                  Types::Nil
+    attribute :healing_dice,             Types.Array(Types::Any)
+    attribute :temp_hp_dice,             Types.Array(Types::Any)
+    attribute :attack_type,              Types::Nil
+    attribute :can_cast_at_higher_level, Types::Bool
+    attribute :is_homebrew,              Types::Bool
+    attribute :version,                  Types::Nil
+    attribute :source_id,                Types::Nil
+    attribute :source_page_number,       Types::Integer
+    attribute :requires_saving_throw,    Types::Bool
+    attribute :requires_attack_roll,     Types::Bool
+    attribute :at_higher_levels,         AtHigherLevels
+    attribute :modifiers,                Types.Array(ItemElement)
+    attribute :conditions,               Types.Array(Types::Any)
+    attribute :tags,                     Types.Array(Types::String)
+    attribute :casting_time_description, Types::String
+    attribute :scale_type,               Types::String
+    attribute :sources,                  Types.Array(Source)
+    attribute :spell_groups,             Types.Array(Types::Any)
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        id:                       d.fetch("id"),
+        definition_key:           d.fetch("definitionKey"),
+        definition_name:          d.fetch("name"),
+        level:                    d.fetch("level"),
+        school:                   d.fetch("school"),
+        duration:                 DefinitionDuration.from_dynamic!(d.fetch("duration")),
+        activation:               Activation.from_dynamic!(d.fetch("activation")),
+        range:                    DefinitionRange.from_dynamic!(d.fetch("range")),
+        as_part_of_weapon_attack: d.fetch("asPartOfWeaponAttack"),
+        description:              d.fetch("description"),
+        snippet:                  d.fetch("snippet"),
+        concentration:            d.fetch("concentration"),
+        ritual:                   d.fetch("ritual"),
+        range_area:               d.fetch("rangeArea"),
+        damage_effect:            d.fetch("damageEffect"),
+        components:               d.fetch("components"),
+        components_description:   d.fetch("componentsDescription"),
+        save_dc_ability_id:       d.fetch("saveDcAbilityId"),
+        healing:                  d.fetch("healing"),
+        healing_dice:             d.fetch("healingDice"),
+        temp_hp_dice:             d.fetch("tempHpDice"),
+        attack_type:              d.fetch("attackType"),
+        can_cast_at_higher_level: d.fetch("canCastAtHigherLevel"),
+        is_homebrew:              d.fetch("isHomebrew"),
+        version:                  d.fetch("version"),
+        source_id:                d.fetch("sourceId"),
+        source_page_number:       d.fetch("sourcePageNumber"),
+        requires_saving_throw:    d.fetch("requiresSavingThrow"),
+        requires_attack_roll:     d.fetch("requiresAttackRoll"),
+        at_higher_levels:         AtHigherLevels.from_dynamic!(d.fetch("atHigherLevels")),
+        modifiers:                d.fetch("modifiers").map { |x| ItemElement.from_dynamic!(x) },
+        conditions:               d.fetch("conditions"),
+        tags:                     d.fetch("tags"),
+        casting_time_description: d.fetch("castingTimeDescription"),
+        scale_type:               d.fetch("scaleType"),
+        sources:                  d.fetch("sources").map { |x| Source.from_dynamic!(x) },
+        spell_groups:             d.fetch("spellGroups"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "id"                     => id,
+        "definitionKey"          => definition_key,
+        "name"                   => definition_name,
+        "level"                  => level,
+        "school"                 => school,
+        "duration"               => duration.to_dynamic,
+        "activation"             => activation.to_dynamic,
+        "range"                  => range.to_dynamic,
+        "asPartOfWeaponAttack"   => as_part_of_weapon_attack,
+        "description"            => description,
+        "snippet"                => snippet,
+        "concentration"          => concentration,
+        "ritual"                 => ritual,
+        "rangeArea"              => range_area,
+        "damageEffect"           => damage_effect,
+        "components"             => components,
+        "componentsDescription"  => components_description,
+        "saveDcAbilityId"        => save_dc_ability_id,
+        "healing"                => healing,
+        "healingDice"            => healing_dice,
+        "tempHpDice"             => temp_hp_dice,
+        "attackType"             => attack_type,
+        "canCastAtHigherLevel"   => can_cast_at_higher_level,
+        "isHomebrew"             => is_homebrew,
+        "version"                => version,
+        "sourceId"               => source_id,
+        "sourcePageNumber"       => source_page_number,
+        "requiresSavingThrow"    => requires_saving_throw,
+        "requiresAttackRoll"     => requires_attack_roll,
+        "atHigherLevels"         => at_higher_levels.to_dynamic,
+        "modifiers"              => modifiers.map { |x| x.to_dynamic },
+        "conditions"             => conditions,
+        "tags"                   => tags,
+        "castingTimeDescription" => casting_time_description,
+        "scaleType"              => scale_type,
+        "sources"                => sources.map { |x| x.to_dynamic },
+        "spellGroups"            => spell_groups,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Item < Dry::Struct
+    attribute :override_save_dc,          Types::Nil
+    attribute :limited_use,               Types::Nil
+    attribute :id,                        Types::Integer
+    attribute :entity_type_id,            Types::Integer
+    attribute :definition,                ItemDefinition
+    attribute :definition_id,             Types::Integer
+    attribute :prepared,                  Types::Bool
+    attribute :counts_as_known_spell,     Types::Nil
+    attribute :uses_spell_slot,           Types::Bool
+    attribute :cast_at_level,             Types::Nil
+    attribute :always_prepared,           Types::Bool
+    attribute :restriction,               Types::Nil
+    attribute :spell_casting_ability_id,  Types::Nil
+    attribute :display_as_attack,         Types::Bool
+    attribute :additional_description,    Types::Nil
+    attribute :cast_only_as_ritual,       Types::Bool
+    attribute :ritual_casting_type,       Types::Nil
+    attribute :range,                     DefinitionRange
+    attribute :activation,                Activation
+    attribute :base_level_at_will,        Types::Bool
+    attribute :at_will_limited_use_level, Types::Nil
+    attribute :is_signature_spell,        Types::Nil
+    attribute :component_id,              Types::Integer
+    attribute :component_type_id,         Types::Integer
+    attribute :spell_list_id,             Types::Nil
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        override_save_dc:          d.fetch("overrideSaveDc"),
+        limited_use:               d.fetch("limitedUse"),
+        id:                        d.fetch("id"),
+        entity_type_id:            d.fetch("entityTypeId"),
+        definition:                ItemDefinition.from_dynamic!(d.fetch("definition")),
+        definition_id:             d.fetch("definitionId"),
+        prepared:                  d.fetch("prepared"),
+        counts_as_known_spell:     d.fetch("countsAsKnownSpell"),
+        uses_spell_slot:           d.fetch("usesSpellSlot"),
+        cast_at_level:             d.fetch("castAtLevel"),
+        always_prepared:           d.fetch("alwaysPrepared"),
+        restriction:               d.fetch("restriction"),
+        spell_casting_ability_id:  d.fetch("spellCastingAbilityId"),
+        display_as_attack:         d.fetch("displayAsAttack"),
+        additional_description:    d.fetch("additionalDescription"),
+        cast_only_as_ritual:       d.fetch("castOnlyAsRitual"),
+        ritual_casting_type:       d.fetch("ritualCastingType"),
+        range:                     DefinitionRange.from_dynamic!(d.fetch("range")),
+        activation:                Activation.from_dynamic!(d.fetch("activation")),
+        base_level_at_will:        d.fetch("baseLevelAtWill"),
+        at_will_limited_use_level: d.fetch("atWillLimitedUseLevel"),
+        is_signature_spell:        d.fetch("isSignatureSpell"),
+        component_id:              d.fetch("componentId"),
+        component_type_id:         d.fetch("componentTypeId"),
+        spell_list_id:             d.fetch("spellListId"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "overrideSaveDc"        => override_save_dc,
+        "limitedUse"            => limited_use,
+        "id"                    => id,
+        "entityTypeId"          => entity_type_id,
+        "definition"            => definition.to_dynamic,
+        "definitionId"          => definition_id,
+        "prepared"              => prepared,
+        "countsAsKnownSpell"    => counts_as_known_spell,
+        "usesSpellSlot"         => uses_spell_slot,
+        "castAtLevel"           => cast_at_level,
+        "alwaysPrepared"        => always_prepared,
+        "restriction"           => restriction,
+        "spellCastingAbilityId" => spell_casting_ability_id,
+        "displayAsAttack"       => display_as_attack,
+        "additionalDescription" => additional_description,
+        "castOnlyAsRitual"      => cast_only_as_ritual,
+        "ritualCastingType"     => ritual_casting_type,
+        "range"                 => range.to_dynamic,
+        "activation"            => activation.to_dynamic,
+        "baseLevelAtWill"       => base_level_at_will,
+        "atWillLimitedUseLevel" => at_will_limited_use_level,
+        "isSignatureSpell"      => is_signature_spell,
+        "componentId"           => component_id,
+        "componentTypeId"       => component_type_id,
+        "spellListId"           => spell_list_id,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Actions < Dry::Struct
+    attribute :race,          Types.Array(Types::Any)
+    attribute :actions_class, Types.Array(ActionsClass)
+    attribute :background,    Types::Nil
+    attribute :item,          Types.Array(Item).optional
+    attribute :feat,          Types.Array(Types::Any)
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        race:          d.fetch("race"),
+        actions_class: d.fetch("class").map { |x| ActionsClass.from_dynamic!(x) },
+        background:    d.fetch("background"),
+        item:          d.fetch("item")&.map { |x| Item.from_dynamic!(x) },
+        feat:          d.fetch("feat"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "race"       => race,
+        "class"      => actions_class.map { |x| x.to_dynamic },
+        "background" => background,
+        "item"       => item&.map { |x| x.to_dynamic },
+        "feat"       => feat,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class CustomBackground < Dry::Struct
+    attribute :id,                                       Types::Integer
+    attribute :entity_type_id,                           Types::Integer
+    attribute :custom_background_name,                   Types::Nil
+    attribute :description,                              Types::Nil
+    attribute :features_background,                      Types::Nil
+    attribute :characteristics_background,               Types::Nil
+    attribute :features_background_definition_id,        Types::Nil
+    attribute :characteristics_background_definition_id, Types::Nil
+    attribute :background_type,                          Types::Nil
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        id:                                       d.fetch("id"),
+        entity_type_id:                           d.fetch("entityTypeId"),
+        custom_background_name:                   d.fetch("name"),
+        description:                              d.fetch("description"),
+        features_background:                      d.fetch("featuresBackground"),
+        characteristics_background:               d.fetch("characteristicsBackground"),
+        features_background_definition_id:        d.fetch("featuresBackgroundDefinitionId"),
+        characteristics_background_definition_id: d.fetch("characteristicsBackgroundDefinitionId"),
+        background_type:                          d.fetch("backgroundType"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "id"                                    => id,
+        "entityTypeId"                          => entity_type_id,
+        "name"                                  => custom_background_name,
+        "description"                           => description,
+        "featuresBackground"                    => features_background,
+        "characteristicsBackground"             => characteristics_background,
+        "featuresBackgroundDefinitionId"        => features_background_definition_id,
+        "characteristicsBackgroundDefinitionId" => characteristics_background_definition_id,
+        "backgroundType"                        => background_type,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Bond < Dry::Struct
+    attribute :id,          Types::Integer
+    attribute :description, Types::String
+    attribute :dice_roll,   Types::Integer
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        id:          d.fetch("id"),
+        description: d.fetch("description"),
+        dice_roll:   d.fetch("diceRoll"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "id"          => id,
+        "description" => description,
+        "diceRoll"    => dice_roll,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class BackgroundDefinition < Dry::Struct
+    attribute :id,                                    Types::Integer
+    attribute :entity_type_id,                        Types::Integer
+    attribute :definition_key,                        Types::String
+    attribute :definition_name,                       Types::String
+    attribute :description,                           Types::String
+    attribute :snippet,                               Types::String
+    attribute :short_description,                     Types::String
+    attribute :skill_proficiencies_description,       Types::String
+    attribute :tool_proficiencies_description,        Types::String
+    attribute :languages_description,                 Types::String
+    attribute :equipment_description,                 Types::String
+    attribute :feature_name,                          Types::String
+    attribute :feature_description,                   Types::String
+    attribute :avatar_url,                            Types::Nil
+    attribute :large_avatar_url,                      Types::Nil
+    attribute :suggested_characteristics_description, Types::String
+    attribute :suggested_proficiencies,               Types::Nil
+    attribute :suggested_languages,                   Types::Nil
+    attribute :organization,                          Types::Nil
+    attribute :contracts_description,                 Types::String
+    attribute :spells_pre_description,                Types::String
+    attribute :spells_post_description,               Types::String
+    attribute :personality_traits,                    Types.Array(Bond)
+    attribute :ideals,                                Types.Array(Bond)
+    attribute :bonds,                                 Types.Array(Bond)
+    attribute :flaws,                                 Types.Array(Bond)
+    attribute :is_homebrew,                           Types::Bool
+    attribute :sources,                               Types.Array(Source)
+    attribute :spell_list_ids,                        Types.Array(Types::Any)
+    attribute :feat_list,                             Types::Nil
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        id:                                    d.fetch("id"),
+        entity_type_id:                        d.fetch("entityTypeId"),
+        definition_key:                        d.fetch("definitionKey"),
+        definition_name:                       d.fetch("name"),
+        description:                           d.fetch("description"),
+        snippet:                               d.fetch("snippet"),
+        short_description:                     d.fetch("shortDescription"),
+        skill_proficiencies_description:       d.fetch("skillProficienciesDescription"),
+        tool_proficiencies_description:        d.fetch("toolProficienciesDescription"),
+        languages_description:                 d.fetch("languagesDescription"),
+        equipment_description:                 d.fetch("equipmentDescription"),
+        feature_name:                          d.fetch("featureName"),
+        feature_description:                   d.fetch("featureDescription"),
+        avatar_url:                            d.fetch("avatarUrl"),
+        large_avatar_url:                      d.fetch("largeAvatarUrl"),
+        suggested_characteristics_description: d.fetch("suggestedCharacteristicsDescription"),
+        suggested_proficiencies:               d.fetch("suggestedProficiencies"),
+        suggested_languages:                   d.fetch("suggestedLanguages"),
+        organization:                          d.fetch("organization"),
+        contracts_description:                 d.fetch("contractsDescription"),
+        spells_pre_description:                d.fetch("spellsPreDescription"),
+        spells_post_description:               d.fetch("spellsPostDescription"),
+        personality_traits:                    d.fetch("personalityTraits").map { |x| Bond.from_dynamic!(x) },
+        ideals:                                d.fetch("ideals").map { |x| Bond.from_dynamic!(x) },
+        bonds:                                 d.fetch("bonds").map { |x| Bond.from_dynamic!(x) },
+        flaws:                                 d.fetch("flaws").map { |x| Bond.from_dynamic!(x) },
+        is_homebrew:                           d.fetch("isHomebrew"),
+        sources:                               d.fetch("sources").map { |x| Source.from_dynamic!(x) },
+        spell_list_ids:                        d.fetch("spellListIds"),
+        feat_list:                             d.fetch("featList"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "id"                                  => id,
+        "entityTypeId"                        => entity_type_id,
+        "definitionKey"                       => definition_key,
+        "name"                                => definition_name,
+        "description"                         => description,
+        "snippet"                             => snippet,
+        "shortDescription"                    => short_description,
+        "skillProficienciesDescription"       => skill_proficiencies_description,
+        "toolProficienciesDescription"        => tool_proficiencies_description,
+        "languagesDescription"                => languages_description,
+        "equipmentDescription"                => equipment_description,
+        "featureName"                         => feature_name,
+        "featureDescription"                  => feature_description,
+        "avatarUrl"                           => avatar_url,
+        "largeAvatarUrl"                      => large_avatar_url,
+        "suggestedCharacteristicsDescription" => suggested_characteristics_description,
+        "suggestedProficiencies"              => suggested_proficiencies,
+        "suggestedLanguages"                  => suggested_languages,
+        "organization"                        => organization,
+        "contractsDescription"                => contracts_description,
+        "spellsPreDescription"                => spells_pre_description,
+        "spellsPostDescription"               => spells_post_description,
+        "personalityTraits"                   => personality_traits.map { |x| x.to_dynamic },
+        "ideals"                              => ideals.map { |x| x.to_dynamic },
+        "bonds"                               => bonds.map { |x| x.to_dynamic },
+        "flaws"                               => flaws.map { |x| x.to_dynamic },
+        "isHomebrew"                          => is_homebrew,
+        "sources"                             => sources.map { |x| x.to_dynamic },
+        "spellListIds"                        => spell_list_ids,
+        "featList"                            => feat_list,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class CharacterBackground < Dry::Struct
+    attribute :has_custom_background, Types::Bool
+    attribute :definition,            BackgroundDefinition
+    attribute :definition_id,         Types::Nil
+    attribute :custom_background,     CustomBackground
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        has_custom_background: d.fetch("hasCustomBackground"),
+        definition:            BackgroundDefinition.from_dynamic!(d.fetch("definition")),
+        definition_id:         d.fetch("definitionId"),
+        custom_background:     CustomBackground.from_dynamic!(d.fetch("customBackground")),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "hasCustomBackground" => has_custom_background,
+        "definition"          => definition.to_dynamic,
+        "definitionId"        => definition_id,
+        "customBackground"    => custom_background.to_dynamic,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Stat < Dry::Struct
+    attribute :id,        Types::Integer
+    attribute :stat_name, Types::Nil
+    attribute :value,     Types::Integer.optional
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        id:        d.fetch("id"),
+        stat_name: d.fetch("name"),
+        value:     d.fetch("value"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "id"    => id,
+        "name"  => stat_name,
+        "value" => value,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class CharacterElement < Dry::Struct
+    attribute :user_id,        Types::Integer
+    attribute :username,       Types::String
+    attribute :character_id,   Types::Integer
+    attribute :character_name, Types::String
+    attribute :character_url,  Types::String
+    attribute :avatar_url,     Types::String.optional
+    attribute :privacy_type,   Types::Integer
+    attribute :campaign_id,    Types::Nil
+    attribute :is_assigned,    Types::Bool
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        user_id:        d.fetch("userId"),
+        username:       d.fetch("username"),
+        character_id:   d.fetch("characterId"),
+        character_name: d.fetch("characterName"),
+        character_url:  d.fetch("characterUrl"),
+        avatar_url:     d.fetch("avatarUrl"),
+        privacy_type:   d.fetch("privacyType"),
+        campaign_id:    d.fetch("campaignId"),
+        is_assigned:    d.fetch("isAssigned"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "userId"        => user_id,
+        "username"      => username,
+        "characterId"   => character_id,
+        "characterName" => character_name,
+        "characterUrl"  => character_url,
+        "avatarUrl"     => avatar_url,
+        "privacyType"   => privacy_type,
+        "campaignId"    => campaign_id,
+        "isAssigned"    => is_assigned,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Campaign < Dry::Struct
+    attribute :id,            Types::Integer
+    attribute :campaign_name, Types::String
+    attribute :description,   Types::String
+    attribute :link,          Types::String
+    attribute :public_notes,  Types::String
+    attribute :dm_user_id,    Types::Integer
+    attribute :dm_username,   Types::String
+    attribute :characters,    Types.Array(CharacterElement)
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        id:            d.fetch("id"),
+        campaign_name: d.fetch("name"),
+        description:   d.fetch("description"),
+        link:          d.fetch("link"),
+        public_notes:  d.fetch("publicNotes"),
+        dm_user_id:    d.fetch("dmUserId"),
+        dm_username:   d.fetch("dmUsername"),
+        characters:    d.fetch("characters").map { |x| CharacterElement.from_dynamic!(x) },
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "id"          => id,
+        "name"        => campaign_name,
+        "description" => description,
+        "link"        => link,
+        "publicNotes" => public_notes,
+        "dmUserId"    => dm_user_id,
+        "dmUsername"  => dm_username,
+        "characters"  => characters.map { |x| x.to_dynamic },
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Definition1 < Dry::Struct
+    attribute :id,                 Types::Integer
+    attribute :entity_type_id,     Types::Integer
+    attribute :definition_name,    Types::String
+    attribute :description,        Types::String
+    attribute :snippet,            Types::String
+    attribute :activation,         Types::Nil
+    attribute :source_id,          Types::Integer
+    attribute :source_page_number, Types::Nil
+    attribute :creature_rules,     Types.Array(Types::Any)
+    attribute :spell_list_ids,     Types.Array(Types::Any)
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        id:                 d.fetch("id"),
+        entity_type_id:     d.fetch("entityTypeId"),
+        definition_name:    d.fetch("name"),
+        description:        d.fetch("description"),
+        snippet:            d.fetch("snippet"),
+        activation:         d.fetch("activation"),
+        source_id:          d.fetch("sourceId"),
+        source_page_number: d.fetch("sourcePageNumber"),
+        creature_rules:     d.fetch("creatureRules"),
+        spell_list_ids:     d.fetch("spellListIds"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "id"               => id,
+        "entityTypeId"     => entity_type_id,
+        "name"             => definition_name,
+        "description"      => description,
+        "snippet"          => snippet,
+        "activation"       => activation,
+        "sourceId"         => source_id,
+        "sourcePageNumber" => source_page_number,
+        "creatureRules"    => creature_rules,
+        "spellListIds"     => spell_list_ids,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class OptionsClass < Dry::Struct
+    attribute :component_id,      Types::Integer
+    attribute :component_type_id, Types::Integer
+    attribute :definition,        Definition1
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        component_id:      d.fetch("componentId"),
+        component_type_id: d.fetch("componentTypeId"),
+        definition:        Definition1.from_dynamic!(d.fetch("definition")),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "componentId"     => component_id,
+        "componentTypeId" => component_type_id,
+        "definition"      => definition.to_dynamic,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Options < Dry::Struct
+    attribute :race,          Types.Array(Types::Any)
+    attribute :options_class, Types.Array(OptionsClass)
+    attribute :background,    Types::Nil
+    attribute :item,          Types::Nil
+    attribute :feat,          Types.Array(Types::Any)
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        race:          d.fetch("race"),
+        options_class: d.fetch("class").map { |x| OptionsClass.from_dynamic!(x) },
+        background:    d.fetch("background"),
+        item:          d.fetch("item"),
+        feat:          d.fetch("feat"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "race"       => race,
+        "class"      => options_class.map { |x| x.to_dynamic },
+        "background" => background,
+        "item"       => item,
+        "feat"       => feat,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class ChoicesBackground < Dry::Struct
+    attribute :component_id,       Types::Integer
+    attribute :component_type_id,  Types::Integer
+    attribute :id,                 Types::String
+    attribute :parent_choice_id,   Types::String.optional
+    attribute :background_type,    Types::Integer
+    attribute :sub_type,           Types::Integer.optional
+    attribute :option_value,       Types::Integer
+    attribute :label,              Types::String.optional
+    attribute :is_optional,        Types::Bool
+    attribute :is_infinite,        Types::Bool
+    attribute :default_subtypes,   Types.Array(Types::String)
+    attribute :display_order,      Types::Nil
+    attribute :background_options, Types.Array(Types::Any)
+    attribute :option_ids,         Types.Array(Types::Integer)
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        component_id:       d.fetch("componentId"),
+        component_type_id:  d.fetch("componentTypeId"),
+        id:                 d.fetch("id"),
+        parent_choice_id:   d.fetch("parentChoiceId"),
+        background_type:    d.fetch("type"),
+        sub_type:           d.fetch("subType"),
+        option_value:       d.fetch("optionValue"),
+        label:              d.fetch("label"),
+        is_optional:        d.fetch("isOptional"),
+        is_infinite:        d.fetch("isInfinite"),
+        default_subtypes:   d.fetch("defaultSubtypes"),
+        display_order:      d.fetch("displayOrder"),
+        background_options: d.fetch("options"),
+        option_ids:         d.fetch("optionIds"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "componentId"     => component_id,
+        "componentTypeId" => component_type_id,
+        "id"              => id,
+        "parentChoiceId"  => parent_choice_id,
+        "type"            => background_type,
+        "subType"         => sub_type,
+        "optionValue"     => option_value,
+        "label"           => label,
+        "isOptional"      => is_optional,
+        "isInfinite"      => is_infinite,
+        "defaultSubtypes" => default_subtypes,
+        "displayOrder"    => display_order,
+        "options"         => background_options,
+        "optionIds"       => option_ids,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Option < Dry::Struct
+    attribute :id,          Types::Integer
+    attribute :label,       Types::String
+    attribute :description, Types::String.optional
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        id:          d.fetch("id"),
+        label:       d.fetch("label"),
+        description: d.fetch("description"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "id"          => id,
+        "label"       => label,
+        "description" => description,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class ChoiceDefinition < Dry::Struct
+    attribute :id,                        Types::String
+    attribute :choice_definition_options, Types.Array(Option)
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        id:                        d.fetch("id"),
+        choice_definition_options: d.fetch("options").map { |x| Option.from_dynamic!(x) },
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "id"      => id,
+        "options" => choice_definition_options.map { |x| x.to_dynamic },
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class DefinitionKeyNameMap < Dry::Struct
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Choices < Dry::Struct
+    attribute :race,                    Types.Array(ChoicesBackground)
+    attribute :choices_class,           Types.Array(ChoicesBackground)
+    attribute :background,              Types.Array(ChoicesBackground)
+    attribute :item,                    Types::Nil
+    attribute :feat,                    Types.Array(ChoicesBackground)
+    attribute :choice_definitions,      Types.Array(ChoiceDefinition)
+    attribute :definition_key_name_map, DefinitionKeyNameMap
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        race:                    d.fetch("race").map { |x| ChoicesBackground.from_dynamic!(x) },
+        choices_class:           d.fetch("class").map { |x| ChoicesBackground.from_dynamic!(x) },
+        background:              d.fetch("background").map { |x| ChoicesBackground.from_dynamic!(x) },
+        item:                    d.fetch("item"),
+        feat:                    d.fetch("feat").map { |x| ChoicesBackground.from_dynamic!(x) },
+        choice_definitions:      d.fetch("choiceDefinitions").map { |x| ChoiceDefinition.from_dynamic!(x) },
+        definition_key_name_map: DefinitionKeyNameMap.from_dynamic!(d.fetch("definitionKeyNameMap")),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "race"                 => race.map { |x| x.to_dynamic },
+        "class"                => choices_class.map { |x| x.to_dynamic },
+        "background"           => background.map { |x| x.to_dynamic },
+        "item"                 => item,
+        "feat"                 => feat.map { |x| x.to_dynamic },
+        "choiceDefinitions"    => choice_definitions.map { |x| x.to_dynamic },
+        "definitionKeyNameMap" => definition_key_name_map.to_dynamic,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class ClassSpell < Dry::Struct
+    attribute :entity_type_id,     Types::Integer
+    attribute :character_class_id, Types::Integer
+    attribute :spells,             Types.Array(Types::Any)
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        entity_type_id:     d.fetch("entityTypeId"),
+        character_class_id: d.fetch("characterClassId"),
+        spells:             d.fetch("spells"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "entityTypeId"     => entity_type_id,
+        "characterClassId" => character_class_id,
+        "spells"           => spells,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  module EntityType
+    ClassFeature = "class-feature"
+  end
+
+  class LevelScale < Dry::Struct
+    attribute :id,          Types::Integer
+    attribute :level,       Types::Integer
+    attribute :description, Types::String
+    attribute :dice,        Die.optional
+    attribute :fixed_value, Types::Integer
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        id:          d.fetch("id"),
+        level:       d.fetch("level"),
+        description: d.fetch("description"),
+        dice:        d.fetch("dice") ? Die.from_dynamic!(d.fetch("dice")) : nil,
+        fixed_value: d.fetch("fixedValue"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "id"          => id,
+        "level"       => level,
+        "description" => description,
+        "dice"        => dice&.to_dynamic,
+        "fixedValue"  => fixed_value,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class LimitedUseElement < Dry::Struct
+    attribute :level, Types::Nil
+    attribute :uses,  Types::Integer
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        level: d.fetch("level"),
+        uses:  d.fetch("uses"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "level" => level,
+        "uses"  => uses,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class ClassFeatureDefinition < Dry::Struct
+    attribute :id,                               Types::Integer
+    attribute :definition_key,                   Types::String
+    attribute :entity_type_id,                   Types::Integer
+    attribute :display_order,                    Types::Integer
+    attribute :definition_name,                  Types::String
+    attribute :description,                      Types::String
+    attribute :snippet,                          Types::String.optional
+    attribute :activation,                       Types::Nil
+    attribute :multi_class_description,          Types::String
+    attribute :required_level,                   Types::Integer
+    attribute :is_sub_class_feature,             Types::Bool
+    attribute :limited_use,                      Types.Array(LimitedUseElement)
+    attribute :hide_in_builder,                  Types::Bool
+    attribute :hide_in_sheet,                    Types::Bool
+    attribute :source_id,                        Types::Integer
+    attribute :source_page_number,               Types::Integer.optional
+    attribute :creature_rules,                   Types.Array(Types::Any)
+    attribute :level_scales,                     Types.Array(LevelScale)
+    attribute :infusion_rules,                   Types.Array(Types::Any)
+    attribute :spell_list_ids,                   Types.Array(Types::Any)
+    attribute :class_id,                         Types::Integer
+    attribute :feature_type,                     Types::Integer
+    attribute :sources,                          Types.Array(Source)
+    attribute :affected_feature_definition_keys, Types.Array(Types::Any)
+    attribute :entity_type,                      Types::EntityType
+    attribute :entity_id,                        Types::String
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        id:                               d.fetch("id"),
+        definition_key:                   d.fetch("definitionKey"),
+        entity_type_id:                   d.fetch("entityTypeId"),
+        display_order:                    d.fetch("displayOrder"),
+        definition_name:                  d.fetch("name"),
+        description:                      d.fetch("description"),
+        snippet:                          d.fetch("snippet"),
+        activation:                       d.fetch("activation"),
+        multi_class_description:          d.fetch("multiClassDescription"),
+        required_level:                   d.fetch("requiredLevel"),
+        is_sub_class_feature:             d.fetch("isSubClassFeature"),
+        limited_use:                      d.fetch("limitedUse").map { |x| LimitedUseElement.from_dynamic!(x) },
+        hide_in_builder:                  d.fetch("hideInBuilder"),
+        hide_in_sheet:                    d.fetch("hideInSheet"),
+        source_id:                        d.fetch("sourceId"),
+        source_page_number:               d.fetch("sourcePageNumber"),
+        creature_rules:                   d.fetch("creatureRules"),
+        level_scales:                     d.fetch("levelScales").map { |x| LevelScale.from_dynamic!(x) },
+        infusion_rules:                   d.fetch("infusionRules"),
+        spell_list_ids:                   d.fetch("spellListIds"),
+        class_id:                         d.fetch("classId"),
+        feature_type:                     d.fetch("featureType"),
+        sources:                          d.fetch("sources").map { |x| Source.from_dynamic!(x) },
+        affected_feature_definition_keys: d.fetch("affectedFeatureDefinitionKeys"),
+        entity_type:                      d.fetch("entityType"),
+        entity_id:                        d.fetch("entityID"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "id"                            => id,
+        "definitionKey"                 => definition_key,
+        "entityTypeId"                  => entity_type_id,
+        "displayOrder"                  => display_order,
+        "name"                          => definition_name,
+        "description"                   => description,
+        "snippet"                       => snippet,
+        "activation"                    => activation,
+        "multiClassDescription"         => multi_class_description,
+        "requiredLevel"                 => required_level,
+        "isSubClassFeature"             => is_sub_class_feature,
+        "limitedUse"                    => limited_use.map { |x| x.to_dynamic },
+        "hideInBuilder"                 => hide_in_builder,
+        "hideInSheet"                   => hide_in_sheet,
+        "sourceId"                      => source_id,
+        "sourcePageNumber"              => source_page_number,
+        "creatureRules"                 => creature_rules,
+        "levelScales"                   => level_scales.map { |x| x.to_dynamic },
+        "infusionRules"                 => infusion_rules,
+        "spellListIds"                  => spell_list_ids,
+        "classId"                       => class_id,
+        "featureType"                   => feature_type,
+        "sources"                       => sources.map { |x| x.to_dynamic },
+        "affectedFeatureDefinitionKeys" => affected_feature_definition_keys,
+        "entityType"                    => entity_type,
+        "entityID"                      => entity_id,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class ClassClassFeature < Dry::Struct
+    attribute :definition,  ClassFeatureDefinition
+    attribute :level_scale, LevelScale.optional
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        definition:  ClassFeatureDefinition.from_dynamic!(d.fetch("definition")),
+        level_scale: d.fetch("levelScale") ? LevelScale.from_dynamic!(d.fetch("levelScale")) : nil,
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "definition" => definition.to_dynamic,
+        "levelScale" => level_scale&.to_dynamic,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class DefinitionClassFeature < Dry::Struct
+    attribute :id,                 Types::Integer
+    attribute :class_feature_name, Types::String
+    attribute :prerequisite,       Types::Nil
+    attribute :description,        Types::String
+    attribute :required_level,     Types::Integer
+    attribute :display_order,      Types::Integer
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        id:                 d.fetch("id"),
+        class_feature_name: d.fetch("name"),
+        prerequisite:       d.fetch("prerequisite"),
+        description:        d.fetch("description"),
+        required_level:     d.fetch("requiredLevel"),
+        display_order:      d.fetch("displayOrder"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "id"            => id,
+        "name"          => class_feature_name,
+        "prerequisite"  => prerequisite,
+        "description"   => description,
+        "requiredLevel" => required_level,
+        "displayOrder"  => display_order,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class PrerequisiteMapping < Dry::Struct
+    attribute :id,                        Types::Integer
+    attribute :entity_id,                 Types::Integer
+    attribute :entity_type_id,            Types::Integer
+    attribute :prerequisite_mapping_type, Types::String
+    attribute :sub_type,                  Types::String
+    attribute :value,                     Types::Integer.optional
+    attribute :friendly_type_name,        Types::String
+    attribute :friendly_sub_type_name,    Types::String
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        id:                        d.fetch("id"),
+        entity_id:                 d.fetch("entityId"),
+        entity_type_id:            d.fetch("entityTypeId"),
+        prerequisite_mapping_type: d.fetch("type"),
+        sub_type:                  d.fetch("subType"),
+        value:                     d.fetch("value"),
+        friendly_type_name:        d.fetch("friendlyTypeName"),
+        friendly_sub_type_name:    d.fetch("friendlySubTypeName"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "id"                  => id,
+        "entityId"            => entity_id,
+        "entityTypeId"        => entity_type_id,
+        "type"                => prerequisite_mapping_type,
+        "subType"             => sub_type,
+        "value"               => value,
+        "friendlyTypeName"    => friendly_type_name,
+        "friendlySubTypeName" => friendly_sub_type_name,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Prerequisite < Dry::Struct
+    attribute :description,           Types::String
+    attribute :prerequisite_mappings, Types.Array(PrerequisiteMapping)
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        description:           d.fetch("description"),
+        prerequisite_mappings: d.fetch("prerequisiteMappings").map { |x| PrerequisiteMapping.from_dynamic!(x) },
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "description"          => description,
+        "prerequisiteMappings" => prerequisite_mappings.map { |x| x.to_dynamic },
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class SpellRules < Dry::Struct
+    attribute :multi_class_spell_slot_divisor,  Types::Integer
+    attribute :is_ritual_spell_caster,          Types::Bool
+    attribute :level_cantrips_known_maxes,      Types.Array(Types::Integer)
+    attribute :level_spell_known_maxes,         Types.Array(Types::Integer)
+    attribute :level_spell_slots,               Types.Array(Types.Array(Types::Integer))
+    attribute :multi_class_spell_slot_rounding, Types::Integer
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        multi_class_spell_slot_divisor:  d.fetch("multiClassSpellSlotDivisor"),
+        is_ritual_spell_caster:          d.fetch("isRitualSpellCaster"),
+        level_cantrips_known_maxes:      d.fetch("levelCantripsKnownMaxes"),
+        level_spell_known_maxes:         d.fetch("levelSpellKnownMaxes"),
+        level_spell_slots:               d.fetch("levelSpellSlots"),
+        multi_class_spell_slot_rounding: d.fetch("multiClassSpellSlotRounding"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "multiClassSpellSlotDivisor"  => multi_class_spell_slot_divisor,
+        "isRitualSpellCaster"         => is_ritual_spell_caster,
+        "levelCantripsKnownMaxes"     => level_cantrips_known_maxes,
+        "levelSpellKnownMaxes"        => level_spell_known_maxes,
+        "levelSpellSlots"             => level_spell_slots,
+        "multiClassSpellSlotRounding" => multi_class_spell_slot_rounding,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class SubclassDefinitionClass < Dry::Struct
+    attribute :id,                       Types::Integer
+    attribute :definition_key,           Types::String
+    attribute :definition_name,          Types::String
+    attribute :description,              Types::String
+    attribute :equipment_description,    Types::String.optional
+    attribute :parent_class_id,          Types::Integer.optional
+    attribute :avatar_url,               Types::String.optional
+    attribute :large_avatar_url,         Types::String.optional
+    attribute :portrait_avatar_url,      Types::String.optional
+    attribute :more_details_url,         Types::String
+    attribute :spell_casting_ability_id, Types::Nil
+    attribute :sources,                  Types.Array(Source)
+    attribute :class_features,           Types.Array(DefinitionClassFeature)
+    attribute :hit_dice,                 Types::Integer
+    attribute :wealth_dice,              Die.optional
+    attribute :can_cast_spells,          Types::Bool
+    attribute :knows_all_spells,         Types::Nil
+    attribute :spell_prepare_type,       Types::Nil
+    attribute :spell_container_name,     Types::Nil
+    attribute :source_page_number,       Types::Integer.optional
+    attribute :subclass_definition,      Types::Nil
+    attribute :is_homebrew,              Types::Bool
+    attribute :primary_abilities,        Types.Array(Types::Integer).optional
+    attribute :spell_rules,              SpellRules.optional
+    attribute :prerequisites,            Types.Array(Prerequisite).optional
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        id:                       d.fetch("id"),
+        definition_key:           d.fetch("definitionKey"),
+        definition_name:          d.fetch("name"),
+        description:              d.fetch("description"),
+        equipment_description:    d.fetch("equipmentDescription"),
+        parent_class_id:          d.fetch("parentClassId"),
+        avatar_url:               d.fetch("avatarUrl"),
+        large_avatar_url:         d.fetch("largeAvatarUrl"),
+        portrait_avatar_url:      d.fetch("portraitAvatarUrl"),
+        more_details_url:         d.fetch("moreDetailsUrl"),
+        spell_casting_ability_id: d.fetch("spellCastingAbilityId"),
+        sources:                  d.fetch("sources").map { |x| Source.from_dynamic!(x) },
+        class_features:           d.fetch("classFeatures").map { |x| DefinitionClassFeature.from_dynamic!(x) },
+        hit_dice:                 d.fetch("hitDice"),
+        wealth_dice:              d.fetch("wealthDice") ? Die.from_dynamic!(d.fetch("wealthDice")) : nil,
+        can_cast_spells:          d.fetch("canCastSpells"),
+        knows_all_spells:         d.fetch("knowsAllSpells"),
+        spell_prepare_type:       d.fetch("spellPrepareType"),
+        spell_container_name:     d.fetch("spellContainerName"),
+        source_page_number:       d.fetch("sourcePageNumber"),
+        subclass_definition:      d.fetch("subclassDefinition"),
+        is_homebrew:              d.fetch("isHomebrew"),
+        primary_abilities:        d.fetch("primaryAbilities"),
+        spell_rules:              d.fetch("spellRules") ? SpellRules.from_dynamic!(d.fetch("spellRules")) : nil,
+        prerequisites:            d.fetch("prerequisites")&.map { |x| Prerequisite.from_dynamic!(x) },
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "id"                    => id,
+        "definitionKey"         => definition_key,
+        "name"                  => definition_name,
+        "description"           => description,
+        "equipmentDescription"  => equipment_description,
+        "parentClassId"         => parent_class_id,
+        "avatarUrl"             => avatar_url,
+        "largeAvatarUrl"        => large_avatar_url,
+        "portraitAvatarUrl"     => portrait_avatar_url,
+        "moreDetailsUrl"        => more_details_url,
+        "spellCastingAbilityId" => spell_casting_ability_id,
+        "sources"               => sources.map { |x| x.to_dynamic },
+        "classFeatures"         => class_features.map { |x| x.to_dynamic },
+        "hitDice"               => hit_dice,
+        "wealthDice"            => wealth_dice&.to_dynamic,
+        "canCastSpells"         => can_cast_spells,
+        "knowsAllSpells"        => knows_all_spells,
+        "spellPrepareType"      => spell_prepare_type,
+        "spellContainerName"    => spell_container_name,
+        "sourcePageNumber"      => source_page_number,
+        "subclassDefinition"    => subclass_definition,
+        "isHomebrew"            => is_homebrew,
+        "primaryAbilities"      => primary_abilities,
+        "spellRules"            => spell_rules&.to_dynamic,
+        "prerequisites"         => prerequisites&.map { |x| x.to_dynamic },
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class CharacterClass < Dry::Struct
+    attribute :id,                     Types::Integer
+    attribute :entity_type_id,         Types::Integer
+    attribute :level,                  Types::Integer
+    attribute :is_starting_class,      Types::Bool
+    attribute :hit_dice_used,          Types::Integer
+    attribute :definition_id,          Types::Integer
+    attribute :subclass_definition_id, Types::Nil
+    attribute :definition,             SubclassDefinitionClass
+    attribute :subclass_definition,    SubclassDefinitionClass
+    attribute :class_features,         Types.Array(ClassClassFeature)
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        id:                     d.fetch("id"),
+        entity_type_id:         d.fetch("entityTypeId"),
+        level:                  d.fetch("level"),
+        is_starting_class:      d.fetch("isStartingClass"),
+        hit_dice_used:          d.fetch("hitDiceUsed"),
+        definition_id:          d.fetch("definitionId"),
+        subclass_definition_id: d.fetch("subclassDefinitionId"),
+        definition:             SubclassDefinitionClass.from_dynamic!(d.fetch("definition")),
+        subclass_definition:    SubclassDefinitionClass.from_dynamic!(d.fetch("subclassDefinition")),
+        class_features:         d.fetch("classFeatures").map { |x| ClassClassFeature.from_dynamic!(x) },
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "id"                   => id,
+        "entityTypeId"         => entity_type_id,
+        "level"                => level,
+        "isStartingClass"      => is_starting_class,
+        "hitDiceUsed"          => hit_dice_used,
+        "definitionId"         => definition_id,
+        "subclassDefinitionId" => subclass_definition_id,
+        "definition"           => definition.to_dynamic,
+        "subclassDefinition"   => subclass_definition.to_dynamic,
+        "classFeatures"        => class_features.map { |x| x.to_dynamic },
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Configuration < Dry::Struct
+    attribute :starting_equipment_type, Types::Integer
+    attribute :ability_score_type,      Types::Integer
+    attribute :show_help_text,          Types::Bool
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        starting_equipment_type: d.fetch("startingEquipmentType"),
+        ability_score_type:      d.fetch("abilityScoreType"),
+        show_help_text:          d.fetch("showHelpText"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "startingEquipmentType" => starting_equipment_type,
+        "abilityScoreType"      => ability_score_type,
+        "showHelpText"          => show_help_text,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Currencies < Dry::Struct
+    attribute :cp, Types::Integer
+    attribute :sp, Types::Integer
+    attribute :gp, Types::Integer
+    attribute :ep, Types::Integer
+    attribute :pp, Types::Integer
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        cp: d.fetch("cp"),
+        sp: d.fetch("sp"),
+        gp: d.fetch("gp"),
+        ep: d.fetch("ep"),
+        pp: d.fetch("pp"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "cp" => cp,
+        "sp" => sp,
+        "gp" => gp,
+        "ep" => ep,
+        "pp" => pp,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class DeathSaves < Dry::Struct
+    attribute :fail_count,    Types::Nil
+    attribute :success_count, Types::Nil
+    attribute :is_stabilized, Types::Bool
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        fail_count:    d.fetch("failCount"),
+        success_count: d.fetch("successCount"),
+        is_stabilized: d.fetch("isStabilized"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "failCount"    => fail_count,
+        "successCount" => success_count,
+        "isStabilized" => is_stabilized,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class DefaultBackdrop < Dry::Struct
+    attribute :backdrop_avatar_url,           Types::String
+    attribute :small_backdrop_avatar_url,     Types::String
+    attribute :large_backdrop_avatar_url,     Types::String
+    attribute :thumbnail_backdrop_avatar_url, Types::String
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        backdrop_avatar_url:           d.fetch("backdropAvatarUrl"),
+        small_backdrop_avatar_url:     d.fetch("smallBackdropAvatarUrl"),
+        large_backdrop_avatar_url:     d.fetch("largeBackdropAvatarUrl"),
+        thumbnail_backdrop_avatar_url: d.fetch("thumbnailBackdropAvatarUrl"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "backdropAvatarUrl"          => backdrop_avatar_url,
+        "smallBackdropAvatarUrl"     => small_backdrop_avatar_url,
+        "largeBackdropAvatarUrl"     => large_backdrop_avatar_url,
+        "thumbnailBackdropAvatarUrl" => thumbnail_backdrop_avatar_url,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Decorations < Dry::Struct
+    attribute :avatar_url,                               Types::Nil
+    attribute :frame_avatar_url,                         Types::Nil
+    attribute :backdrop_avatar_url,                      Types::Nil
+    attribute :small_backdrop_avatar_url,                Types::Nil
+    attribute :large_backdrop_avatar_url,                Types::Nil
+    attribute :thumbnail_backdrop_avatar_url,            Types::Nil
+    attribute :default_backdrop,                         DefaultBackdrop
+    attribute :avatar_id,                                Types::Nil
+    attribute :portrait_decoration_key,                  Types::Nil
+    attribute :frame_avatar_decoration_key,              Types::Nil
+    attribute :frame_avatar_id,                          Types::Nil
+    attribute :backdrop_avatar_decoration_key,           Types::Nil
+    attribute :backdrop_avatar_id,                       Types::Nil
+    attribute :small_backdrop_avatar_decoration_key,     Types::String
+    attribute :small_backdrop_avatar_id,                 Types::Nil
+    attribute :large_backdrop_avatar_decoration_key,     Types::String
+    attribute :large_backdrop_avatar_id,                 Types::Nil
+    attribute :thumbnail_backdrop_avatar_decoration_key, Types::String
+    attribute :thumbnail_backdrop_avatar_id,             Types::Nil
+    attribute :theme_color,                              Types::Nil
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        avatar_url:                               d.fetch("avatarUrl"),
+        frame_avatar_url:                         d.fetch("frameAvatarUrl"),
+        backdrop_avatar_url:                      d.fetch("backdropAvatarUrl"),
+        small_backdrop_avatar_url:                d.fetch("smallBackdropAvatarUrl"),
+        large_backdrop_avatar_url:                d.fetch("largeBackdropAvatarUrl"),
+        thumbnail_backdrop_avatar_url:            d.fetch("thumbnailBackdropAvatarUrl"),
+        default_backdrop:                         DefaultBackdrop.from_dynamic!(d.fetch("defaultBackdrop")),
+        avatar_id:                                d.fetch("avatarId"),
+        portrait_decoration_key:                  d.fetch("portraitDecorationKey"),
+        frame_avatar_decoration_key:              d.fetch("frameAvatarDecorationKey"),
+        frame_avatar_id:                          d.fetch("frameAvatarId"),
+        backdrop_avatar_decoration_key:           d.fetch("backdropAvatarDecorationKey"),
+        backdrop_avatar_id:                       d.fetch("backdropAvatarId"),
+        small_backdrop_avatar_decoration_key:     d.fetch("smallBackdropAvatarDecorationKey"),
+        small_backdrop_avatar_id:                 d.fetch("smallBackdropAvatarId"),
+        large_backdrop_avatar_decoration_key:     d.fetch("largeBackdropAvatarDecorationKey"),
+        large_backdrop_avatar_id:                 d.fetch("largeBackdropAvatarId"),
+        thumbnail_backdrop_avatar_decoration_key: d.fetch("thumbnailBackdropAvatarDecorationKey"),
+        thumbnail_backdrop_avatar_id:             d.fetch("thumbnailBackdropAvatarId"),
+        theme_color:                              d.fetch("themeColor"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "avatarUrl"                            => avatar_url,
+        "frameAvatarUrl"                       => frame_avatar_url,
+        "backdropAvatarUrl"                    => backdrop_avatar_url,
+        "smallBackdropAvatarUrl"               => small_backdrop_avatar_url,
+        "largeBackdropAvatarUrl"               => large_backdrop_avatar_url,
+        "thumbnailBackdropAvatarUrl"           => thumbnail_backdrop_avatar_url,
+        "defaultBackdrop"                      => default_backdrop.to_dynamic,
+        "avatarId"                             => avatar_id,
+        "portraitDecorationKey"                => portrait_decoration_key,
+        "frameAvatarDecorationKey"             => frame_avatar_decoration_key,
+        "frameAvatarId"                        => frame_avatar_id,
+        "backdropAvatarDecorationKey"          => backdrop_avatar_decoration_key,
+        "backdropAvatarId"                     => backdrop_avatar_id,
+        "smallBackdropAvatarDecorationKey"     => small_backdrop_avatar_decoration_key,
+        "smallBackdropAvatarId"                => small_backdrop_avatar_id,
+        "largeBackdropAvatarDecorationKey"     => large_backdrop_avatar_decoration_key,
+        "largeBackdropAvatarId"                => large_backdrop_avatar_id,
+        "thumbnailBackdropAvatarDecorationKey" => thumbnail_backdrop_avatar_decoration_key,
+        "thumbnailBackdropAvatarId"            => thumbnail_backdrop_avatar_id,
+        "themeColor"                           => theme_color,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class FeatDefinition < Dry::Struct
+    attribute :id,                 Types::Integer
+    attribute :entity_type_id,     Types::Integer
+    attribute :definition_key,     Types::String
+    attribute :definition_name,    Types::String
+    attribute :description,        Types::String
+    attribute :snippet,            Types::String
+    attribute :activation,         Activation
+    attribute :source_id,          Types::Nil
+    attribute :source_page_number, Types::Nil
+    attribute :creature_rules,     Types.Array(Types::Any)
+    attribute :prerequisites,      Types.Array(Prerequisite)
+    attribute :is_homebrew,        Types::Bool
+    attribute :sources,            Types.Array(Source)
+    attribute :spell_list_ids,     Types.Array(Types::Any)
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        id:                 d.fetch("id"),
+        entity_type_id:     d.fetch("entityTypeId"),
+        definition_key:     d.fetch("definitionKey"),
+        definition_name:    d.fetch("name"),
+        description:        d.fetch("description"),
+        snippet:            d.fetch("snippet"),
+        activation:         Activation.from_dynamic!(d.fetch("activation")),
+        source_id:          d.fetch("sourceId"),
+        source_page_number: d.fetch("sourcePageNumber"),
+        creature_rules:     d.fetch("creatureRules"),
+        prerequisites:      d.fetch("prerequisites").map { |x| Prerequisite.from_dynamic!(x) },
+        is_homebrew:        d.fetch("isHomebrew"),
+        sources:            d.fetch("sources").map { |x| Source.from_dynamic!(x) },
+        spell_list_ids:     d.fetch("spellListIds"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "id"               => id,
+        "entityTypeId"     => entity_type_id,
+        "definitionKey"    => definition_key,
+        "name"             => definition_name,
+        "description"      => description,
+        "snippet"          => snippet,
+        "activation"       => activation.to_dynamic,
+        "sourceId"         => source_id,
+        "sourcePageNumber" => source_page_number,
+        "creatureRules"    => creature_rules,
+        "prerequisites"    => prerequisites.map { |x| x.to_dynamic },
+        "isHomebrew"       => is_homebrew,
+        "sources"          => sources.map { |x| x.to_dynamic },
+        "spellListIds"     => spell_list_ids,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Feat < Dry::Struct
+    attribute :component_type_id, Types::Integer
+    attribute :component_id,      Types::Integer
+    attribute :definition,        FeatDefinition
+    attribute :definition_id,     Types::Integer
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        component_type_id: d.fetch("componentTypeId"),
+        component_id:      d.fetch("componentId"),
+        definition:        FeatDefinition.from_dynamic!(d.fetch("definition")),
+        definition_id:     d.fetch("definitionId"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "componentTypeId" => component_type_id,
+        "componentId"     => component_id,
+        "definition"      => definition.to_dynamic,
+        "definitionId"    => definition_id,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  module ContainerDefinitionKey
+    The158111142353552888 = "1581111423:53552888"
+  end
+
+  module FilterType
+    Armor     = "Armor"
+    OtherGear = "Other Gear"
+    Potion    = "Potion"
+    Weapon    = "Weapon"
+  end
+
+  class Property < Dry::Struct
+    attribute :id,            Types::Integer
+    attribute :property_name, Types::String
+    attribute :description,   Types::String
+    attribute :notes,         Types::String.optional
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        id:            d.fetch("id"),
+        property_name: d.fetch("name"),
+        description:   d.fetch("description"),
+        notes:         d.fetch("notes"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "id"          => id,
+        "name"        => property_name,
+        "description" => description,
+        "notes"       => notes,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  module Rarity
+    Common   = "Common"
+    Rare     = "Rare"
+    Uncommon = "Uncommon"
+  end
+
+  class InventoryDefinition < Dry::Struct
+    attribute :id,                        Types::Integer
+    attribute :base_type_id,              Types::Integer
+    attribute :entity_type_id,            Types::Integer
+    attribute :definition_key,            Types::String
+    attribute :can_equip,                 Types::Bool
+    attribute :magic,                     Types::Bool
+    attribute :definition_name,           Types::String
+    attribute :snippet,                   Types::String.optional
+    attribute :weight,                    Types::Double
+    attribute :weight_multiplier,         Types::Integer
+    attribute :capacity,                  Types::String.optional
+    attribute :capacity_weight,           Types::Integer
+    attribute :definition_type,           Types::String
+    attribute :description,               Types::String
+    attribute :can_attune,                Types::Bool
+    attribute :attunement_description,    Types::String.optional
+    attribute :rarity,                    Types::Rarity
+    attribute :is_homebrew,               Types::Bool
+    attribute :version,                   Types::Nil
+    attribute :source_id,                 Types::Nil
+    attribute :source_page_number,        Types::Nil
+    attribute :stackable,                 Types::Bool
+    attribute :bundle_size,               Types::Integer
+    attribute :avatar_url,                Types::Nil
+    attribute :large_avatar_url,          Types::Nil
+    attribute :filter_type,               Types::FilterType
+    attribute :cost,                      Types::Double.optional
+    attribute :is_pack,                   Types::Bool
+    attribute :tags,                      Types.Array(Types::String)
+    attribute :granted_modifiers,         Types.Array(ItemElement)
+    attribute :sub_type,                  Types::String.optional
+    attribute :is_consumable,             Types::Bool
+    attribute :weapon_behaviors,          Types.Array(Types::Any)
+    attribute :base_item_id,              Types::Integer.optional
+    attribute :base_armor_name,           Types::String.optional
+    attribute :strength_requirement,      Types::Integer.optional
+    attribute :armor_class,               Types::Integer.optional
+    attribute :stealth_check,             Types::Integer.optional
+    attribute :damage,                    Die.optional
+    attribute :damage_type,               Types::String.optional
+    attribute :fixed_damage,              Types::Nil
+    attribute :properties,                Types.Array(Property).optional
+    attribute :attack_type,               Types::Integer.optional
+    attribute :category_id,               Types::Integer.optional
+    attribute :range,                     Types::Integer.optional
+    attribute :long_range,                Types::Integer.optional
+    attribute :is_monk_weapon,            Types::Bool
+    attribute :level_infusion_granted,    Types::Nil
+    attribute :sources,                   Types.Array(Source)
+    attribute :armor_type_id,             Types::Integer.optional
+    attribute :gear_type_id,              Types::Integer.optional
+    attribute :grouped_id,                Types::Integer.optional
+    attribute :can_be_added_to_inventory, Types::Bool
+    attribute :is_container,              Types::Bool
+    attribute :is_custom_item,            Types::Bool
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        id:                        d.fetch("id"),
+        base_type_id:              d.fetch("baseTypeId"),
+        entity_type_id:            d.fetch("entityTypeId"),
+        definition_key:            d.fetch("definitionKey"),
+        can_equip:                 d.fetch("canEquip"),
+        magic:                     d.fetch("magic"),
+        definition_name:           d.fetch("name"),
+        snippet:                   d.fetch("snippet"),
+        weight:                    d.fetch("weight"),
+        weight_multiplier:         d.fetch("weightMultiplier"),
+        capacity:                  d.fetch("capacity"),
+        capacity_weight:           d.fetch("capacityWeight"),
+        definition_type:           d.fetch("type"),
+        description:               d.fetch("description"),
+        can_attune:                d.fetch("canAttune"),
+        attunement_description:    d.fetch("attunementDescription"),
+        rarity:                    d.fetch("rarity"),
+        is_homebrew:               d.fetch("isHomebrew"),
+        version:                   d.fetch("version"),
+        source_id:                 d.fetch("sourceId"),
+        source_page_number:        d.fetch("sourcePageNumber"),
+        stackable:                 d.fetch("stackable"),
+        bundle_size:               d.fetch("bundleSize"),
+        avatar_url:                d.fetch("avatarUrl"),
+        large_avatar_url:          d.fetch("largeAvatarUrl"),
+        filter_type:               d.fetch("filterType"),
+        cost:                      d.fetch("cost"),
+        is_pack:                   d.fetch("isPack"),
+        tags:                      d.fetch("tags"),
+        granted_modifiers:         d.fetch("grantedModifiers").map { |x| ItemElement.from_dynamic!(x) },
+        sub_type:                  d.fetch("subType"),
+        is_consumable:             d.fetch("isConsumable"),
+        weapon_behaviors:          d.fetch("weaponBehaviors"),
+        base_item_id:              d.fetch("baseItemId"),
+        base_armor_name:           d.fetch("baseArmorName"),
+        strength_requirement:      d.fetch("strengthRequirement"),
+        armor_class:               d.fetch("armorClass"),
+        stealth_check:             d.fetch("stealthCheck"),
+        damage:                    d.fetch("damage") ? Die.from_dynamic!(d.fetch("damage")) : nil,
+        damage_type:               d.fetch("damageType"),
+        fixed_damage:              d.fetch("fixedDamage"),
+        properties:                d.fetch("properties")&.map { |x| Property.from_dynamic!(x) },
+        attack_type:               d.fetch("attackType"),
+        category_id:               d.fetch("categoryId"),
+        range:                     d.fetch("range"),
+        long_range:                d.fetch("longRange"),
+        is_monk_weapon:            d.fetch("isMonkWeapon"),
+        level_infusion_granted:    d.fetch("levelInfusionGranted"),
+        sources:                   d.fetch("sources").map { |x| Source.from_dynamic!(x) },
+        armor_type_id:             d.fetch("armorTypeId"),
+        gear_type_id:              d.fetch("gearTypeId"),
+        grouped_id:                d.fetch("groupedId"),
+        can_be_added_to_inventory: d.fetch("canBeAddedToInventory"),
+        is_container:              d.fetch("isContainer"),
+        is_custom_item:            d.fetch("isCustomItem"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "id"                    => id,
+        "baseTypeId"            => base_type_id,
+        "entityTypeId"          => entity_type_id,
+        "definitionKey"         => definition_key,
+        "canEquip"              => can_equip,
+        "magic"                 => magic,
+        "name"                  => definition_name,
+        "snippet"               => snippet,
+        "weight"                => weight,
+        "weightMultiplier"      => weight_multiplier,
+        "capacity"              => capacity,
+        "capacityWeight"        => capacity_weight,
+        "type"                  => definition_type,
+        "description"           => description,
+        "canAttune"             => can_attune,
+        "attunementDescription" => attunement_description,
+        "rarity"                => rarity,
+        "isHomebrew"            => is_homebrew,
+        "version"               => version,
+        "sourceId"              => source_id,
+        "sourcePageNumber"      => source_page_number,
+        "stackable"             => stackable,
+        "bundleSize"            => bundle_size,
+        "avatarUrl"             => avatar_url,
+        "largeAvatarUrl"        => large_avatar_url,
+        "filterType"            => filter_type,
+        "cost"                  => cost,
+        "isPack"                => is_pack,
+        "tags"                  => tags,
+        "grantedModifiers"      => granted_modifiers.map { |x| x.to_dynamic },
+        "subType"               => sub_type,
+        "isConsumable"          => is_consumable,
+        "weaponBehaviors"       => weapon_behaviors,
+        "baseItemId"            => base_item_id,
+        "baseArmorName"         => base_armor_name,
+        "strengthRequirement"   => strength_requirement,
+        "armorClass"            => armor_class,
+        "stealthCheck"          => stealth_check,
+        "damage"                => damage&.to_dynamic,
+        "damageType"            => damage_type,
+        "fixedDamage"           => fixed_damage,
+        "properties"            => properties&.map { |x| x.to_dynamic },
+        "attackType"            => attack_type,
+        "categoryId"            => category_id,
+        "range"                 => range,
+        "longRange"             => long_range,
+        "isMonkWeapon"          => is_monk_weapon,
+        "levelInfusionGranted"  => level_infusion_granted,
+        "sources"               => sources.map { |x| x.to_dynamic },
+        "armorTypeId"           => armor_type_id,
+        "gearTypeId"            => gear_type_id,
+        "groupedId"             => grouped_id,
+        "canBeAddedToInventory" => can_be_added_to_inventory,
+        "isContainer"           => is_container,
+        "isCustomItem"          => is_custom_item,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class InventoryLimitedUse < Dry::Struct
+    attribute :max_uses,               Types::Integer
+    attribute :number_used,            Types::Integer
+    attribute :reset_type,             Types::String
+    attribute :reset_type_description, Types::String
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        max_uses:               d.fetch("maxUses"),
+        number_used:            d.fetch("numberUsed"),
+        reset_type:             d.fetch("resetType"),
+        reset_type_description: d.fetch("resetTypeDescription"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "maxUses"              => max_uses,
+        "numberUsed"           => number_used,
+        "resetType"            => reset_type,
+        "resetTypeDescription" => reset_type_description,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Inventory < Dry::Struct
+    attribute :id,                       Types::Integer
+    attribute :entity_type_id,           Types::Integer
+    attribute :definition,               InventoryDefinition
+    attribute :definition_id,            Types::Integer
+    attribute :definition_type_id,       Types::Integer
+    attribute :display_as_attack,        Types::Nil
+    attribute :quantity,                 Types::Integer
+    attribute :is_attuned,               Types::Bool
+    attribute :equipped,                 Types::Bool
+    attribute :equipped_entity_type_id,  Types::Integer.optional
+    attribute :equipped_entity_id,       Types::Integer.optional
+    attribute :charges_used,             Types::Integer
+    attribute :limited_use,              InventoryLimitedUse.optional
+    attribute :container_entity_id,      Types::Integer
+    attribute :container_entity_type_id, Types::Integer
+    attribute :container_definition_key, Types::ContainerDefinitionKey
+    attribute :currency,                 Types::Nil
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        id:                       d.fetch("id"),
+        entity_type_id:           d.fetch("entityTypeId"),
+        definition:               InventoryDefinition.from_dynamic!(d.fetch("definition")),
+        definition_id:            d.fetch("definitionId"),
+        definition_type_id:       d.fetch("definitionTypeId"),
+        display_as_attack:        d.fetch("displayAsAttack"),
+        quantity:                 d.fetch("quantity"),
+        is_attuned:               d.fetch("isAttuned"),
+        equipped:                 d.fetch("equipped"),
+        equipped_entity_type_id:  d.fetch("equippedEntityTypeId"),
+        equipped_entity_id:       d.fetch("equippedEntityId"),
+        charges_used:             d.fetch("chargesUsed"),
+        limited_use:              d.fetch("limitedUse") ? InventoryLimitedUse.from_dynamic!(d.fetch("limitedUse")) : nil,
+        container_entity_id:      d.fetch("containerEntityId"),
+        container_entity_type_id: d.fetch("containerEntityTypeId"),
+        container_definition_key: d.fetch("containerDefinitionKey"),
+        currency:                 d.fetch("currency"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "id"                     => id,
+        "entityTypeId"           => entity_type_id,
+        "definition"             => definition.to_dynamic,
+        "definitionId"           => definition_id,
+        "definitionTypeId"       => definition_type_id,
+        "displayAsAttack"        => display_as_attack,
+        "quantity"               => quantity,
+        "isAttuned"              => is_attuned,
+        "equipped"               => equipped,
+        "equippedEntityTypeId"   => equipped_entity_type_id,
+        "equippedEntityId"       => equipped_entity_id,
+        "chargesUsed"            => charges_used,
+        "limitedUse"             => limited_use&.to_dynamic,
+        "containerEntityId"      => container_entity_id,
+        "containerEntityTypeId"  => container_entity_type_id,
+        "containerDefinitionKey" => container_definition_key,
+        "currency"               => currency,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Modifiers < Dry::Struct
+    attribute :race,            Types.Array(ItemElement)
+    attribute :modifiers_class, Types.Array(ItemElement)
+    attribute :background,      Types.Array(ItemElement)
+    attribute :item,            Types.Array(ItemElement)
+    attribute :feat,            Types.Array(ItemElement)
+    attribute :condition,       Types.Array(Types::Any)
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        race:            d.fetch("race").map { |x| ItemElement.from_dynamic!(x) },
+        modifiers_class: d.fetch("class").map { |x| ItemElement.from_dynamic!(x) },
+        background:      d.fetch("background").map { |x| ItemElement.from_dynamic!(x) },
+        item:            d.fetch("item").map { |x| ItemElement.from_dynamic!(x) },
+        feat:            d.fetch("feat").map { |x| ItemElement.from_dynamic!(x) },
+        condition:       d.fetch("condition"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "race"       => race.map { |x| x.to_dynamic },
+        "class"      => modifiers_class.map { |x| x.to_dynamic },
+        "background" => background.map { |x| x.to_dynamic },
+        "item"       => item.map { |x| x.to_dynamic },
+        "feat"       => feat.map { |x| x.to_dynamic },
+        "condition"  => condition,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Notes < Dry::Struct
+    attribute :allies,               Types::Nil
+    attribute :personal_possessions, Types::String
+    attribute :other_holdings,       Types::Nil
+    attribute :organizations,        Types::Nil
+    attribute :enemies,              Types::Nil
+    attribute :backstory,            Types::Nil
+    attribute :other_notes,          Types::Nil
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        allies:               d.fetch("allies"),
+        personal_possessions: d.fetch("personalPossessions"),
+        other_holdings:       d.fetch("otherHoldings"),
+        organizations:        d.fetch("organizations"),
+        enemies:              d.fetch("enemies"),
+        backstory:            d.fetch("backstory"),
+        other_notes:          d.fetch("otherNotes"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "allies"              => allies,
+        "personalPossessions" => personal_possessions,
+        "otherHoldings"       => other_holdings,
+        "organizations"       => organizations,
+        "enemies"             => enemies,
+        "backstory"           => backstory,
+        "otherNotes"          => other_notes,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class PactMagic < Dry::Struct
+    attribute :level,     Types::Integer
+    attribute :used,      Types::Integer
+    attribute :available, Types::Integer
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        level:     d.fetch("level"),
+        used:      d.fetch("used"),
+        available: d.fetch("available"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "level"     => level,
+        "used"      => used,
+        "available" => available,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Preferences < Dry::Struct
+    attribute :use_homebrew_content,           Types::Bool
+    attribute :progression_type,               Types::Integer
+    attribute :encumbrance_type,               Types::Integer
+    attribute :ignore_coin_weight,             Types::Bool
+    attribute :hit_point_type,                 Types::Integer
+    attribute :show_unarmed_strike,            Types::Bool
+    attribute :show_scaled_spells,             Types::Bool
+    attribute :primary_sense,                  Types::Integer
+    attribute :primary_movement,               Types::Integer
+    attribute :privacy_type,                   Types::Integer
+    attribute :sharing_type,                   Types::Integer
+    attribute :ability_score_display_type,     Types::Integer
+    attribute :enforce_feat_rules,             Types::Bool
+    attribute :enforce_multiclass_rules,       Types::Bool
+    attribute :enable_optional_class_features, Types::Bool
+    attribute :enable_optional_origins,        Types::Bool
+    attribute :enable_dark_mode,               Types::Bool
+    attribute :enable_container_currency,      Types::Bool
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        use_homebrew_content:           d.fetch("useHomebrewContent"),
+        progression_type:               d.fetch("progressionType"),
+        encumbrance_type:               d.fetch("encumbranceType"),
+        ignore_coin_weight:             d.fetch("ignoreCoinWeight"),
+        hit_point_type:                 d.fetch("hitPointType"),
+        show_unarmed_strike:            d.fetch("showUnarmedStrike"),
+        show_scaled_spells:             d.fetch("showScaledSpells"),
+        primary_sense:                  d.fetch("primarySense"),
+        primary_movement:               d.fetch("primaryMovement"),
+        privacy_type:                   d.fetch("privacyType"),
+        sharing_type:                   d.fetch("sharingType"),
+        ability_score_display_type:     d.fetch("abilityScoreDisplayType"),
+        enforce_feat_rules:             d.fetch("enforceFeatRules"),
+        enforce_multiclass_rules:       d.fetch("enforceMulticlassRules"),
+        enable_optional_class_features: d.fetch("enableOptionalClassFeatures"),
+        enable_optional_origins:        d.fetch("enableOptionalOrigins"),
+        enable_dark_mode:               d.fetch("enableDarkMode"),
+        enable_container_currency:      d.fetch("enableContainerCurrency"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "useHomebrewContent"          => use_homebrew_content,
+        "progressionType"             => progression_type,
+        "encumbranceType"             => encumbrance_type,
+        "ignoreCoinWeight"            => ignore_coin_weight,
+        "hitPointType"                => hit_point_type,
+        "showUnarmedStrike"           => show_unarmed_strike,
+        "showScaledSpells"            => show_scaled_spells,
+        "primarySense"                => primary_sense,
+        "primaryMovement"             => primary_movement,
+        "privacyType"                 => privacy_type,
+        "sharingType"                 => sharing_type,
+        "abilityScoreDisplayType"     => ability_score_display_type,
+        "enforceFeatRules"            => enforce_feat_rules,
+        "enforceMulticlassRules"      => enforce_multiclass_rules,
+        "enableOptionalClassFeatures" => enable_optional_class_features,
+        "enableOptionalOrigins"       => enable_optional_origins,
+        "enableDarkMode"              => enable_dark_mode,
+        "enableContainerCurrency"     => enable_container_currency,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class DisplayConfiguration < Dry::Struct
+    attribute :racialtrait,  Types::Integer
+    attribute :language,     Types::Integer
+    attribute :abilityscore, Types::Integer
+    attribute :classfeature, Types::Integer
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        racialtrait:  d.fetch("RACIALTRAIT"),
+        language:     d.fetch("LANGUAGE"),
+        abilityscore: d.fetch("ABILITYSCORE"),
+        classfeature: d.fetch("CLASSFEATURE"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "RACIALTRAIT"  => racialtrait,
+        "LANGUAGE"     => language,
+        "ABILITYSCORE" => abilityscore,
+        "CLASSFEATURE" => classfeature,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class RacialTraitDefinition < Dry::Struct
+    attribute :id,                               Types::Integer
+    attribute :definition_key,                   Types::String
+    attribute :entity_type_id,                   Types::Integer
+    attribute :display_order,                    Types::Integer
+    attribute :definition_name,                  Types::String
+    attribute :description,                      Types::String
+    attribute :snippet,                          Types::String.optional
+    attribute :hide_in_builder,                  Types::Bool
+    attribute :hide_in_sheet,                    Types::Bool
+    attribute :activation,                       Types::Nil
+    attribute :source_id,                        Types::Integer
+    attribute :source_page_number,               Types::Integer
+    attribute :creature_rules,                   Types.Array(Types::Any)
+    attribute :spell_list_ids,                   Types.Array(Types::Any)
+    attribute :feature_type,                     Types::Integer
+    attribute :sources,                          Types.Array(Source)
+    attribute :affected_feature_definition_keys, Types.Array(Types::Any)
+    attribute :is_called_out,                    Types::Bool
+    attribute :entity_type,                      Types::String
+    attribute :entity_id,                        Types::String
+    attribute :entity_race_id,                   Types::Integer
+    attribute :entity_race_type_id,              Types::Integer
+    attribute :display_configuration,            DisplayConfiguration
+    attribute :required_level,                   Types::Nil
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        id:                               d.fetch("id"),
+        definition_key:                   d.fetch("definitionKey"),
+        entity_type_id:                   d.fetch("entityTypeId"),
+        display_order:                    d.fetch("displayOrder"),
+        definition_name:                  d.fetch("name"),
+        description:                      d.fetch("description"),
+        snippet:                          d.fetch("snippet"),
+        hide_in_builder:                  d.fetch("hideInBuilder"),
+        hide_in_sheet:                    d.fetch("hideInSheet"),
+        activation:                       d.fetch("activation"),
+        source_id:                        d.fetch("sourceId"),
+        source_page_number:               d.fetch("sourcePageNumber"),
+        creature_rules:                   d.fetch("creatureRules"),
+        spell_list_ids:                   d.fetch("spellListIds"),
+        feature_type:                     d.fetch("featureType"),
+        sources:                          d.fetch("sources").map { |x| Source.from_dynamic!(x) },
+        affected_feature_definition_keys: d.fetch("affectedFeatureDefinitionKeys"),
+        is_called_out:                    d.fetch("isCalledOut"),
+        entity_type:                      d.fetch("entityType"),
+        entity_id:                        d.fetch("entityID"),
+        entity_race_id:                   d.fetch("entityRaceId"),
+        entity_race_type_id:              d.fetch("entityRaceTypeId"),
+        display_configuration:            DisplayConfiguration.from_dynamic!(d.fetch("displayConfiguration")),
+        required_level:                   d.fetch("requiredLevel"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "id"                            => id,
+        "definitionKey"                 => definition_key,
+        "entityTypeId"                  => entity_type_id,
+        "displayOrder"                  => display_order,
+        "name"                          => definition_name,
+        "description"                   => description,
+        "snippet"                       => snippet,
+        "hideInBuilder"                 => hide_in_builder,
+        "hideInSheet"                   => hide_in_sheet,
+        "activation"                    => activation,
+        "sourceId"                      => source_id,
+        "sourcePageNumber"              => source_page_number,
+        "creatureRules"                 => creature_rules,
+        "spellListIds"                  => spell_list_ids,
+        "featureType"                   => feature_type,
+        "sources"                       => sources.map { |x| x.to_dynamic },
+        "affectedFeatureDefinitionKeys" => affected_feature_definition_keys,
+        "isCalledOut"                   => is_called_out,
+        "entityType"                    => entity_type,
+        "entityID"                      => entity_id,
+        "entityRaceId"                  => entity_race_id,
+        "entityRaceTypeId"              => entity_race_type_id,
+        "displayConfiguration"          => display_configuration.to_dynamic,
+        "requiredLevel"                 => required_level,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class RacialTrait < Dry::Struct
+    attribute :definition, RacialTraitDefinition
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        definition: RacialTraitDefinition.from_dynamic!(d.fetch("definition")),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "definition" => definition.to_dynamic,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Normal < Dry::Struct
+    attribute :walk,   Types::Integer
+    attribute :fly,    Types::Integer
+    attribute :burrow, Types::Integer
+    attribute :swim,   Types::Integer
+    attribute :climb,  Types::Integer
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        walk:   d.fetch("walk"),
+        fly:    d.fetch("fly"),
+        burrow: d.fetch("burrow"),
+        swim:   d.fetch("swim"),
+        climb:  d.fetch("climb"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "walk"   => walk,
+        "fly"    => fly,
+        "burrow" => burrow,
+        "swim"   => swim,
+        "climb"  => climb,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class WeightSpeeds < Dry::Struct
+    attribute :normal,             Normal
+    attribute :encumbered,         Types::Nil
+    attribute :heavily_encumbered, Types::Nil
+    attribute :push_drag_lift,     Types::Nil
+    attribute :override,           Types::Nil
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        normal:             Normal.from_dynamic!(d.fetch("normal")),
+        encumbered:         d.fetch("encumbered"),
+        heavily_encumbered: d.fetch("heavilyEncumbered"),
+        push_drag_lift:     d.fetch("pushDragLift"),
+        override:           d.fetch("override"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "normal"            => normal.to_dynamic,
+        "encumbered"        => encumbered,
+        "heavilyEncumbered" => heavily_encumbered,
+        "pushDragLift"      => push_drag_lift,
+        "override"          => override,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Race < Dry::Struct
+    attribute :is_sub_race,         Types::Bool
+    attribute :base_race_name,      Types::String
+    attribute :entity_race_id,      Types::Integer
+    attribute :entity_race_type_id, Types::Integer
+    attribute :definition_key,      Types::String
+    attribute :full_name,           Types::String
+    attribute :base_race_id,        Types::Integer
+    attribute :base_race_type_id,   Types::Integer
+    attribute :description,         Types::String
+    attribute :avatar_url,          Types::String
+    attribute :large_avatar_url,    Types::String
+    attribute :portrait_avatar_url, Types::String
+    attribute :more_details_url,    Types::String
+    attribute :is_homebrew,         Types::Bool
+    attribute :is_legacy,           Types::Bool
+    attribute :group_ids,           Types.Array(Types::Integer)
+    attribute :race_type,           Types::Integer
+    attribute :supports_subrace,    Types::Nil
+    attribute :sub_race_short_name, Types::Nil
+    attribute :base_name,           Types::String
+    attribute :racial_traits,       Types.Array(RacialTrait)
+    attribute :weight_speeds,       WeightSpeeds
+    attribute :feat_ids,            Types.Array(Types::Any)
+    attribute :size,                Types::Nil
+    attribute :size_id,             Types::Integer
+    attribute :sources,             Types.Array(Source)
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        is_sub_race:         d.fetch("isSubRace"),
+        base_race_name:      d.fetch("baseRaceName"),
+        entity_race_id:      d.fetch("entityRaceId"),
+        entity_race_type_id: d.fetch("entityRaceTypeId"),
+        definition_key:      d.fetch("definitionKey"),
+        full_name:           d.fetch("fullName"),
+        base_race_id:        d.fetch("baseRaceId"),
+        base_race_type_id:   d.fetch("baseRaceTypeId"),
+        description:         d.fetch("description"),
+        avatar_url:          d.fetch("avatarUrl"),
+        large_avatar_url:    d.fetch("largeAvatarUrl"),
+        portrait_avatar_url: d.fetch("portraitAvatarUrl"),
+        more_details_url:    d.fetch("moreDetailsUrl"),
+        is_homebrew:         d.fetch("isHomebrew"),
+        is_legacy:           d.fetch("isLegacy"),
+        group_ids:           d.fetch("groupIds"),
+        race_type:           d.fetch("type"),
+        supports_subrace:    d.fetch("supportsSubrace"),
+        sub_race_short_name: d.fetch("subRaceShortName"),
+        base_name:           d.fetch("baseName"),
+        racial_traits:       d.fetch("racialTraits").map { |x| RacialTrait.from_dynamic!(x) },
+        weight_speeds:       WeightSpeeds.from_dynamic!(d.fetch("weightSpeeds")),
+        feat_ids:            d.fetch("featIds"),
+        size:                d.fetch("size"),
+        size_id:             d.fetch("sizeId"),
+        sources:             d.fetch("sources").map { |x| Source.from_dynamic!(x) },
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "isSubRace"         => is_sub_race,
+        "baseRaceName"      => base_race_name,
+        "entityRaceId"      => entity_race_id,
+        "entityRaceTypeId"  => entity_race_type_id,
+        "definitionKey"     => definition_key,
+        "fullName"          => full_name,
+        "baseRaceId"        => base_race_id,
+        "baseRaceTypeId"    => base_race_type_id,
+        "description"       => description,
+        "avatarUrl"         => avatar_url,
+        "largeAvatarUrl"    => large_avatar_url,
+        "portraitAvatarUrl" => portrait_avatar_url,
+        "moreDetailsUrl"    => more_details_url,
+        "isHomebrew"        => is_homebrew,
+        "isLegacy"          => is_legacy,
+        "groupIds"          => group_ids,
+        "type"              => race_type,
+        "supportsSubrace"   => supports_subrace,
+        "subRaceShortName"  => sub_race_short_name,
+        "baseName"          => base_name,
+        "racialTraits"      => racial_traits.map { |x| x.to_dynamic },
+        "weightSpeeds"      => weight_speeds.to_dynamic,
+        "featIds"           => feat_ids,
+        "size"              => size,
+        "sizeId"            => size_id,
+        "sources"           => sources.map { |x| x.to_dynamic },
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Traits < Dry::Struct
+    attribute :personality_traits, Types::String
+    attribute :ideals,             Types::String
+    attribute :bonds,              Types::String
+    attribute :flaws,              Types::String
+    attribute :appearance,         Types::Nil
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        personality_traits: d.fetch("personalityTraits"),
+        ideals:             d.fetch("ideals"),
+        bonds:              d.fetch("bonds"),
+        flaws:              d.fetch("flaws"),
+        appearance:         d.fetch("appearance"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "personalityTraits" => personality_traits,
+        "ideals"            => ideals,
+        "bonds"             => bonds,
+        "flaws"             => flaws,
+        "appearance"        => appearance,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+
+  class Character < Dry::Struct
+    attribute :id,                         Types::Integer
+    attribute :user_id,                    Types::Integer
+    attribute :username,                   Types::String
+    attribute :is_assigned_to_player,      Types::Bool
+    attribute :readonly_url,               Types::String
+    attribute :decorations,                Decorations
+    attribute :character_name,             Types::String
+    attribute :social_name,                Types::Nil
+    attribute :gender,                     Types::String
+    attribute :faith,                      Types::String
+    attribute :age,                        Types::Integer
+    attribute :hair,                       Types::String
+    attribute :eyes,                       Types::String
+    attribute :skin,                       Types::String
+    attribute :height,                     Types::String
+    attribute :weight,                     Types::Integer
+    attribute :inspiration,                Types::Bool
+    attribute :base_hit_points,            Types::Integer
+    attribute :bonus_hit_points,           Types::Nil
+    attribute :override_hit_points,        Types::Nil
+    attribute :removed_hit_points,         Types::Integer
+    attribute :temporary_hit_points,       Types::Integer
+    attribute :current_xp,                 Types::Integer
+    attribute :alignment_id,               Types::Integer
+    attribute :lifestyle_id,               Types::Integer
+    attribute :stats,                      Types.Array(Stat)
+    attribute :bonus_stats,                Types.Array(Stat)
+    attribute :override_stats,             Types.Array(Stat)
+    attribute :background,                 CharacterBackground
+    attribute :race,                       Race
+    attribute :race_definition_id,         Types::Nil
+    attribute :race_definition_type_id,    Types::Nil
+    attribute :notes,                      Notes
+    attribute :traits,                     Traits
+    attribute :preferences,                Preferences
+    attribute :configuration,              Configuration
+    attribute :lifestyle,                  Types::Nil
+    attribute :inventory,                  Types.Array(Inventory)
+    attribute :currencies,                 Currencies
+    attribute :classes,                    Types.Array(CharacterClass)
+    attribute :feats,                      Types.Array(Feat)
+    attribute :features,                   Types.Array(Types::Any)
+    attribute :custom_defense_adjustments, Types.Array(Types::Any)
+    attribute :custom_senses,              Types.Array(Types::Any)
+    attribute :custom_speeds,              Types.Array(Types::Any)
+    attribute :custom_proficiencies,       Types.Array(Types::Any)
+    attribute :custom_actions,             Types.Array(Types::Any)
+    attribute :character_values,           Types.Array(Types::Any)
+    attribute :conditions,                 Types.Array(Types::Any)
+    attribute :death_saves,                DeathSaves
+    attribute :adjustment_xp,              Types::Nil
+    attribute :spell_slots,                Types.Array(PactMagic)
+    attribute :pact_magic,                 Types.Array(PactMagic)
+    attribute :active_source_categories,   Types.Array(Types::Integer)
+    attribute :spells,                     Actions
+    attribute :character_options,          Options
+    attribute :choices,                    Choices
+    attribute :actions,                    Actions
+    attribute :modifiers,                  Modifiers
+    attribute :class_spells,               Types.Array(ClassSpell)
+    attribute :custom_items,               Types.Array(Types::Any)
+    attribute :campaign,                   Campaign
+    attribute :creatures,                  Types.Array(Types::Any)
+    attribute :optional_origins,           Types.Array(Types::Any)
+    attribute :optional_class_features,    Types.Array(Types::Any)
+    attribute :date_modified,              Types::String
+    attribute :provided_from,              Types::String
+    attribute :can_edit,                   Types::Bool
+    attribute :status,                     Types::Integer
+    attribute :status_slug,                Types::String
+    attribute :campaign_setting,           Types::Nil
+
+    def self.from_dynamic!(d)
+      d = Types::Hash[d]
+      new(
+        id:                         d.fetch("id"),
+        user_id:                    d.fetch("userId"),
+        username:                   d.fetch("username"),
+        is_assigned_to_player:      d.fetch("isAssignedToPlayer"),
+        readonly_url:               d.fetch("readonlyUrl"),
+        decorations:                Decorations.from_dynamic!(d.fetch("decorations")),
+        character_name:             d.fetch("name"),
+        social_name:                d.fetch("socialName"),
+        gender:                     d.fetch("gender"),
+        faith:                      d.fetch("faith"),
+        age:                        d.fetch("age"),
+        hair:                       d.fetch("hair"),
+        eyes:                       d.fetch("eyes"),
+        skin:                       d.fetch("skin"),
+        height:                     d.fetch("height"),
+        weight:                     d.fetch("weight"),
+        inspiration:                d.fetch("inspiration"),
+        base_hit_points:            d.fetch("baseHitPoints"),
+        bonus_hit_points:           d.fetch("bonusHitPoints"),
+        override_hit_points:        d.fetch("overrideHitPoints"),
+        removed_hit_points:         d.fetch("removedHitPoints"),
+        temporary_hit_points:       d.fetch("temporaryHitPoints"),
+        current_xp:                 d.fetch("currentXp"),
+        alignment_id:               d.fetch("alignmentId"),
+        lifestyle_id:               d.fetch("lifestyleId"),
+        stats:                      d.fetch("stats").map { |x| Stat.from_dynamic!(x) },
+        bonus_stats:                d.fetch("bonusStats").map { |x| Stat.from_dynamic!(x) },
+        override_stats:             d.fetch("overrideStats").map { |x| Stat.from_dynamic!(x) },
+        background:                 CharacterBackground.from_dynamic!(d.fetch("background")),
+        race:                       Race.from_dynamic!(d.fetch("race")),
+        race_definition_id:         d.fetch("raceDefinitionId"),
+        race_definition_type_id:    d.fetch("raceDefinitionTypeId"),
+        notes:                      Notes.from_dynamic!(d.fetch("notes")),
+        traits:                     Traits.from_dynamic!(d.fetch("traits")),
+        preferences:                Preferences.from_dynamic!(d.fetch("preferences")),
+        configuration:              Configuration.from_dynamic!(d.fetch("configuration")),
+        lifestyle:                  d.fetch("lifestyle"),
+        inventory:                  d.fetch("inventory").map { |x| Inventory.from_dynamic!(x) },
+        currencies:                 Currencies.from_dynamic!(d.fetch("currencies")),
+        classes:                    d.fetch("classes").map { |x| CharacterClass.from_dynamic!(x) },
+        feats:                      d.fetch("feats").map { |x| Feat.from_dynamic!(x) },
+        features:                   d.fetch("features"),
+        custom_defense_adjustments: d.fetch("customDefenseAdjustments"),
+        custom_senses:              d.fetch("customSenses"),
+        custom_speeds:              d.fetch("customSpeeds"),
+        custom_proficiencies:       d.fetch("customProficiencies"),
+        custom_actions:             d.fetch("customActions"),
+        character_values:           d.fetch("characterValues"),
+        conditions:                 d.fetch("conditions"),
+        death_saves:                DeathSaves.from_dynamic!(d.fetch("deathSaves")),
+        adjustment_xp:              d.fetch("adjustmentXp"),
+        spell_slots:                d.fetch("spellSlots").map { |x| PactMagic.from_dynamic!(x) },
+        pact_magic:                 d.fetch("pactMagic").map { |x| PactMagic.from_dynamic!(x) },
+        active_source_categories:   d.fetch("activeSourceCategories"),
+        spells:                     Actions.from_dynamic!(d.fetch("spells")),
+        character_options:          Options.from_dynamic!(d.fetch("options")),
+        choices:                    Choices.from_dynamic!(d.fetch("choices")),
+        actions:                    Actions.from_dynamic!(d.fetch("actions")),
+        modifiers:                  Modifiers.from_dynamic!(d.fetch("modifiers")),
+        class_spells:               d.fetch("classSpells").map { |x| ClassSpell.from_dynamic!(x) },
+        custom_items:               d.fetch("customItems"),
+        campaign:                   Campaign.from_dynamic!(d.fetch("campaign")),
+        creatures:                  d.fetch("creatures"),
+        optional_origins:           d.fetch("optionalOrigins"),
+        optional_class_features:    d.fetch("optionalClassFeatures"),
+        date_modified:              d.fetch("dateModified"),
+        provided_from:              d.fetch("providedFrom"),
+        can_edit:                   d.fetch("canEdit"),
+        status:                     d.fetch("status"),
+        status_slug:                d.fetch("statusSlug"),
+        campaign_setting:           d.fetch("campaignSetting"),
+      )
+    end
+
+    def self.from_json!(json)
+      from_dynamic!(JSON.parse(json))
+    end
+
+    def to_dynamic
+      {
+        "id"                       => id,
+        "userId"                   => user_id,
+        "username"                 => username,
+        "isAssignedToPlayer"       => is_assigned_to_player,
+        "readonlyUrl"              => readonly_url,
+        "decorations"              => decorations.to_dynamic,
+        "name"                     => character_name,
+        "socialName"               => social_name,
+        "gender"                   => gender,
+        "faith"                    => faith,
+        "age"                      => age,
+        "hair"                     => hair,
+        "eyes"                     => eyes,
+        "skin"                     => skin,
+        "height"                   => height,
+        "weight"                   => weight,
+        "inspiration"              => inspiration,
+        "baseHitPoints"            => base_hit_points,
+        "bonusHitPoints"           => bonus_hit_points,
+        "overrideHitPoints"        => override_hit_points,
+        "removedHitPoints"         => removed_hit_points,
+        "temporaryHitPoints"       => temporary_hit_points,
+        "currentXp"                => current_xp,
+        "alignmentId"              => alignment_id,
+        "lifestyleId"              => lifestyle_id,
+        "stats"                    => stats.map { |x| x.to_dynamic },
+        "bonusStats"               => bonus_stats.map { |x| x.to_dynamic },
+        "overrideStats"            => override_stats.map { |x| x.to_dynamic },
+        "background"               => background.to_dynamic,
+        "race"                     => race.to_dynamic,
+        "raceDefinitionId"         => race_definition_id,
+        "raceDefinitionTypeId"     => race_definition_type_id,
+        "notes"                    => notes.to_dynamic,
+        "traits"                   => traits.to_dynamic,
+        "preferences"              => preferences.to_dynamic,
+        "configuration"            => configuration.to_dynamic,
+        "lifestyle"                => lifestyle,
+        "inventory"                => inventory.map { |x| x.to_dynamic },
+        "currencies"               => currencies.to_dynamic,
+        "classes"                  => classes.map { |x| x.to_dynamic },
+        "feats"                    => feats.map { |x| x.to_dynamic },
+        "features"                 => features,
+        "customDefenseAdjustments" => custom_defense_adjustments,
+        "customSenses"             => custom_senses,
+        "customSpeeds"             => custom_speeds,
+        "customProficiencies"      => custom_proficiencies,
+        "customActions"            => custom_actions,
+        "characterValues"          => character_values,
+        "conditions"               => conditions,
+        "deathSaves"               => death_saves.to_dynamic,
+        "adjustmentXp"             => adjustment_xp,
+        "spellSlots"               => spell_slots.map { |x| x.to_dynamic },
+        "pactMagic"                => pact_magic.map { |x| x.to_dynamic },
+        "activeSourceCategories"   => active_source_categories,
+        "spells"                   => spells.to_dynamic,
+        "options"                  => character_options.to_dynamic,
+        "choices"                  => choices.to_dynamic,
+        "actions"                  => actions.to_dynamic,
+        "modifiers"                => modifiers.to_dynamic,
+        "classSpells"              => class_spells.map { |x| x.to_dynamic },
+        "customItems"              => custom_items,
+        "campaign"                 => campaign.to_dynamic,
+        "creatures"                => creatures,
+        "optionalOrigins"          => optional_origins,
+        "optionalClassFeatures"    => optional_class_features,
+        "dateModified"             => date_modified,
+        "providedFrom"             => provided_from,
+        "canEdit"                  => can_edit,
+        "status"                   => status,
+        "statusSlug"               => status_slug,
+        "campaignSetting"          => campaign_setting,
+      }
+    end
+
+    def to_json(options = nil)
+      JSON.generate(to_dynamic, options)
+    end
+  end
+end