Pathfinder 1e for Foundry VTT
    Preparing search index...

    Class BaseCharacterModel

    Base data model for character-type actors (Character & NPC)

    Hierarchy (View Summary)

    Index

    Constructors

    constructor

    Properties

    abilities ac altCurrency attributes config currency details skills spells traits

    Accessors

    _skillTargets sourceInfo

    Methods

    _addReactiveValues _computeEncumbrance _detectHealthChange _finalizeBooks _finalizeTraits _generateSpellbookCache _initializeBaseValues _prepareBooks _prepareChanges _prepareHealth _prepareNaturalReach _prepareOverlandSpeeds _prepareSenses _prepareSkills _prepareTraits _preUpdate _setSkillFlags finalize getCarryCapacity getCoinWeight getDefenses hasArmorProficiency hasWeaponProficiency onRestUpdate prepareBaseData prepareCMB prepareDependentData prepareDerivedData preparePostChanges refreshDerivedData defineSchema migrateData pruneData

    Constructors

    Properties

    abilities: Record<string, AbilityData>
    ac:
        | undefined
        | {
            natural: { base: number; enh: number; misc: number; total: number };
            normal: { base: number; enh: number; misc: number; total: number };
            shield: { base: number; enh: number; misc: number; total: number };
        }
    altCurrency: Record<string, number>
    attributes: {
        ac: { normal: { ability: string }; touch: { ability: string } };
        acNotes: string;
        attack: { meleeAbility: string; rangedAbility: string };
        cmbAbility: string;
        cmd: { dexAbility: string; strAbility: string };
        cmdNotes: string;
        encumbrance: {
            carriedWeight: number;
            level: number;
            levels: {
                carry: number;
                drag: number;
                heavy: number;
                light: number;
                medium: number;
                overhead: number;
            };
        };
        energyDrain: number;
        hp: { nonlethal: number; offset: number; temp: number };
        hpAbility: string;
        init: { ability: string; value: number };
        naturalAC: number;
        quadruped: boolean;
        saveNotes: string;
        savingThrows: Record<string, SaveData>;
        speed: {
            burrow: { base: number };
            climb: { base: number };
            fly: {
                base: number;
                maneuverability: "good" | "average" | "clumsy" | "poor" | "perfect";
            };
            land: { base: number };
            swim: { base: number };
        };
        sr: { formula: string };
        srNotes: string;
        vigor: { offset: number; temp: number };
        wounds: { offset: number };
    }
    config: {}
    currency: Record<string, number>
    details: {
        age: string;
        alignment: "lg" | "tn" | "ng" | "cg" | "ln" | "cn" | "le" | "ne" | "ce";
        biography: { value: string };
        bonusFeatFormula: string;
        bonusSkillRankFormula: string;
        carryCapacity: {
            bonus: { user: number };
            multiplier: { base: number; user: number };
        };
        deity: string;
        gender: string;
        height: string;
        notes: { value: string };
        weight: string;
        xp: { value: number };
    }
    skills: Record<string, SkillModel>
    spells: Record<string, SpellbookModel>
    traits: {
        ageCategory: "adult" | "young" | "middleAge" | "old" | "venerable";
        armorProf: Set<string>;
        aura: { custom: string };
        ci: Set<string>;
        cres: string;
        di: Set<string>;
        dv: Set<string>;
        fastHealing: string;
        hardness: number;
        languages: Set<
            | "dark"
            | "aboleth"
            | "abyssal"
            | "aklo"
            | "ancientosiriani"
            | "androffan"
            | "aquan"
            | "auran"
            | "azlanti"
            | "boggard"
            | "catfolk"
            | "celestial"
            | "common"
            | "cyclops"
            | "draconic"
            | "drowsign"
            | "druidic"
            | "dtang"
            | "dwarven"
            | "dziriak"
            | "elderthing"
            | "elven"
            | "giant"
            | "gnoll"
            | "gnome"
            | "goblin"
            | "grippli"
            | "grioth"
            | "halfling"
            | "hallit"
            | "honla"
            | "hwan"
            | "ib"
            | "ignan"
            | "infernal"
            | "jistka"
            | "kasatha"
            | "kelish"
            | "kuru"
            | "lashunta"
            | "migo"
            | "minatan"
            | "minkaian"
            | "munavri"
            | "nagaji"
            | "necril"
            | "orc"
            | "orvian"
            | "osiriani"
            | "polyglot"
            | "protean"
            | "reptoid"
            | "rougarou"
            | "samsaran"
            | "sasquatch"
            | "senzar"
            | "shadowtongue"
            | "shae"
            | "shoanti"
            | "skald"
            | "sphinx"
            | "strix"
            | "sylvan"
            | "syrinx"
            | "taldane"
            | "tekritanin"
            | "tengu"
            | "terran"
            | "thassilonian"
            | "tien"
            | "treant"
            | "triaxian"
            | "undercommon"
            | "vanaran"
            | "varisian"
            | "vegepygmy"
            | "vishkanya"
            | "vudrani"
            | "wayang"
            | "yaddithian"
            | "yithian",
        >;
        regen: string;
        senses: {
            bs: { value: number };
            bse: { value: number };
            custom: string;
            dv: { value: number };
            ll: { enabled: boolean; multiplier: { bright: number; dim: number } };
            ls: { value: number };
            lv: { value: number };
            sc: { value: number };
            si: boolean;
            sid: boolean;
            ths: { value: number };
            tr: { value: number };
            ts: { value: number };
        };
        size: | "dim"
        | "med"
        | "fine"
        | "tiny"
        | "sm"
        | "lg"
        | "huge"
        | "grg"
        | "col";
        stature: "long"
        | "tall";
        weaponProf: Set<string>;
    }

    Accessors

    _skillTargets

    • get _skillTargets(): string[]
      Internal

      Retrieve valid skill change targets for this actor.

      Returns string[]

      • Skill target array
    • get sourceInfo(): any

      Returns any

      • This is for conversion compatibility and is not meant to work.
      • Remove before next release

    Methods

    _addReactiveValues

    • _addReactiveValues(): void

      Add getters for values that are fine calculating themselves

      Returns void

    _computeEncumbrance

    • _computeEncumbrance(): MobilityPenaltyResult
      Internal

      Computes encumbrance values for this actor.

      Returns MobilityPenaltyResult

      The resulting penalties from encumbrance.

    _detectHealthChange

    • _detectHealthChange(changed: any, context: any): void

      Parameters

      • changed: any
      • context: any

      Returns void

    _finalizeBooks

    • _finalizeBooks(): void
      Internal

      Finalize data in spellbooks

      Returns void

    Protected_finalizeTraits

    • _finalizeTraits(): void
      Protected

      Finalize preparing armor, weapon, and language proficiencies and other traits.

      Returns void

    _generateSpellbookCache

    • _generateSpellbookCache(): {
          books: Record<string, Spellbook>;
          spells: ItemSpellPF[];
      }
      Internal

      Collect some basic spellbook info so it doesn't need to be gathered again for each spellbook.

      Returns { books: Record<string, Spellbook>; spells: ItemSpellPF[] }

      Spellbook cache

    _initializeBaseValues

    • _initializeBaseValues(): void

      Returns void

    _prepareBooks

    • _prepareBooks(): void
      Internal

      Prepare spellbook data

      Returns void

    _prepareChanges

    • _prepareChanges(changes: any): void

      Prepare changes specific to this actor type

      Parameters

      • changes: any

      Returns void

    _prepareHealth

    • _prepareHealth(allClasses: any, changes: ItemChange[]): void
      Internal

      Calculate maximum health

      Parameters

      Returns void

      _prepareChanges

    Protected_prepareNaturalReach

    • _prepareNaturalReach(): void
      Protected

      Prepare natural reach for melee range and for reach weapons.

      Returns void

    Protected_prepareOverlandSpeeds

    • _prepareOverlandSpeeds(): void
      Protected

      Calculate overland speeds.

      Returns void

    _prepareSenses

    • _prepareSenses(): void

      Returns void

    _prepareSkills

    • _prepareSkills(): void

      Prepare Skills

      Returns void

    _prepareTraits

    • _prepareTraits(): void
      Internal

      Returns void

    _preUpdate

    • _preUpdate(changed: object, context: object, user: User): void
      Internal

      Parameters

      • changed: object
      • context: object
      • user: User

      Returns void

    Protected_setSkillFlags

    • _setSkillFlags(): void
      Protected

      Reset class skills & background skills.

      Returns void

    • Called at end of ()

      Returns void

    • Calculate current carry capacity limits.

      Returns { heavy: number; light: number; medium: number }

      • Capacity info
    • Internal

      Returns number

      • Total coin weight in lbs

    • Returns { di: Set<string>; dr: any; dv: Set<string>; er: any; h: number }

    • Checks if there's any matching proficiency

      Parameters

      • item: ItemEquipmentPF

        The item to check for.

      Returns boolean

      Whether the actor is proficient with that item.

    • Test if actor is proficient with specified weapon.

      Parameters

      • item: ItemPF

        Item to test

      • Optionaloptions: { override?: boolean } = {}

        Additional options

        • Optionaloverride?: boolean

          Allow item's proficiency override to influence the result.

      Returns boolean

      • Proficiency state
    • Protected

      Prepare total CMB value.

      Returns void

      Move all the logic here to the Change system.

    • Prepare data post embedded documents have been prepared.

      This is before changes and before prepareDerivedData()

      Returns void

    • Returns void

    • Prepare data post change application.

      Returns void

    • Base actor class with minimal functionality.

      Provides only caching of .itemTypes and nothing else.

      Returns void

    • Returns {
          abilities: TypedObjectField<
              SchemaField<
                  {
                      damage: NumberField<
                          {
                              initial: undefined;
                              integer: true;
                              min: 0;
                              nullable: true;
                              required: false;
                          },
                          AssignmentType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: false;
                              },
                          >,
                          InitializedType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: false;
                              },
                          >,
                          InitializedType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: false;
                              },
                          >,
                      >;
                      drain: NumberField<
                          {
                              initial: undefined;
                              integer: true;
                              min: 0;
                              nullable: true;
                              required: false;
                          },
                          AssignmentType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: false;
                              },
                          >,
                          InitializedType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: false;
                              },
                          >,
                          InitializedType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: false;
                              },
                          >,
                      >;
                      userPenalty: NumberField<
                          {
                              initial: undefined;
                              integer: true;
                              min: 0;
                              nullable: true;
                              required: false;
                          },
                          AssignmentType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: false;
                              },
                          >,
                          InitializedType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: false;
                              },
                          >,
                          InitializedType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: false;
                              },
                          >,
                      >;
                      value: NumberField<
                          { initial: 10; min: 0; nullable: true; required: false },
                          AssignmentType<
                              { initial: 10; min: 0; nullable: true; required: false },
                          >,
                          InitializedType<
                              { initial: 10; min: 0; nullable: true; required: false },
                          >,
                          InitializedType<
                              { initial: 10; min: 0; nullable: true; required: false },
                          >,
                      >;
                  },
                  DefaultOptions,
                  AssignmentType<
                      {
                          damage: NumberField<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: false;
                              },
                              AssignmentType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: false;
                                  },
                              >,
                              InitializedType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: false;
                                  },
                              >,
                              InitializedType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: false;
                                  },
                              >,
                          >;
                          drain: NumberField<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: false;
                              },
                              AssignmentType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: false;
                                  },
                              >,
                              InitializedType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: false;
                                  },
                              >,
                              InitializedType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: false;
                                  },
                              >,
                          >;
                          userPenalty: NumberField<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: false;
                              },
                              AssignmentType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: false;
                                  },
                              >,
                              InitializedType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: false;
                                  },
                              >,
                              InitializedType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: false;
                                  },
                              >,
                          >;
                          value: NumberField<
                              { initial: 10; min: 0; nullable: true; required: false },
                              AssignmentType<
                                  { initial: 10; min: 0; nullable: true; required: false },
                              >,
                              InitializedType<
                                  { initial: 10; min: 0; nullable: true; required: false },
                              >,
                              InitializedType<
                                  { initial: 10; min: 0; nullable: true; required: false },
                              >,
                          >;
                      },
                      SimpleMerge<DefaultOptions, DefaultOptions>,
                  >,
                  {
                      damage: InitializedType<
                          {
                              initial: undefined;
                              integer: true;
                              min: 0;
                              nullable: true;
                              required: false;
                          },
                      >;
                      drain: InitializedType<
                          {
                              initial: undefined;
                              integer: true;
                              min: 0;
                              nullable: true;
                              required: false;
                          },
                      >;
                      userPenalty: InitializedType<
                          {
                              initial: undefined;
                              integer: true;
                              min: 0;
                              nullable: true;
                              required: false;
                          },
                      >;
                      value: InitializedType<
                          { initial: 10; min: 0; nullable: true; required: false },
                      >;
                  },
                  {
                      damage: InitializedType<
                          {
                              initial: undefined;
                              integer: true;
                              min: 0;
                              nullable: true;
                              required: false;
                          },
                      >;
                      drain: InitializedType<
                          {
                              initial: undefined;
                              integer: true;
                              min: 0;
                              nullable: true;
                              required: false;
                          },
                      >;
                      userPenalty: InitializedType<
                          {
                              initial: undefined;
                              integer: true;
                              min: 0;
                              nullable: true;
                              required: false;
                          },
                      >;
                      value: InitializedType<
                          { initial: 10; min: 0; nullable: true; required: false },
                      >;
                  },
              >,
              DefaultOptions,
              AssignmentType<
                  SchemaField<
                      {
                          damage: NumberField<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: false;
                              },
                              AssignmentType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: false;
                                  },
                              >,
                              InitializedType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: false;
                                  },
                              >,
                              InitializedType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: false;
                                  },
                              >,
                          >;
                          drain: NumberField<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: false;
                              },
                              AssignmentType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: false;
                                  },
                              >,
                              InitializedType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: false;
                                  },
                              >,
                              InitializedType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: false;
                                  },
                              >,
                          >;
                          userPenalty: NumberField<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: false;
                              },
                              AssignmentType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: false;
                                  },
                              >,
                              InitializedType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: false;
                                  },
                              >,
                              InitializedType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: false;
                                  },
                              >,
                          >;
                          value: NumberField<
                              { initial: 10; min: 0; nullable: true; required: false },
                              AssignmentType<
                                  { initial: 10; min: 0; nullable: true; required: false },
                              >,
                              InitializedType<
                                  { initial: 10; min: 0; nullable: true; required: false },
                              >,
                              InitializedType<
                                  { initial: 10; min: 0; nullable: true; required: false },
                              >,
                          >;
                      },
                      DefaultOptions,
                      AssignmentType<
                          {
                              damage: NumberField<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: false;
                                  },
                                  AssignmentType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: false;
                                      },
                                  >,
                                  InitializedType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: false;
                                      },
                                  >,
                                  InitializedType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: false;
                                      },
                                  >,
                              >;
                              drain: NumberField<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: false;
                                  },
                                  AssignmentType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: false;
                                      },
                                  >,
                                  InitializedType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: false;
                                      },
                                  >,
                                  InitializedType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: false;
                                      },
                                  >,
                              >;
                              userPenalty: NumberField<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: false;
                                  },
                                  AssignmentType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: false;
                                      },
                                  >,
                                  InitializedType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: false;
                                      },
                                  >,
                                  InitializedType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: false;
                                      },
                                  >,
                              >;
                              value: NumberField<
                                  { initial: 10; min: 0; nullable: true; required: false },
                                  AssignmentType<
                                      { initial: 10; min: 0; nullable: true; required: false },
                                  >,
                                  InitializedType<
                                      { initial: 10; min: 0; nullable: true; required: false },
                                  >,
                                  InitializedType<
                                      { initial: 10; min: 0; nullable: true; required: false },
                                  >,
                              >;
                          },
                          SimpleMerge<DefaultOptions, DefaultOptions>,
                      >,
                      {
                          damage: InitializedType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: false;
                              },
                          >;
                          drain: InitializedType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: false;
                              },
                          >;
                          userPenalty: InitializedType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: false;
                              },
                          >;
                          value: InitializedType<
                              { initial: 10; min: 0; nullable: true; required: false },
                          >;
                      },
                      {
                          damage: InitializedType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: false;
                              },
                          >;
                          drain: InitializedType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: false;
                              },
                          >;
                          userPenalty: InitializedType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: false;
                              },
                          >;
                          value: InitializedType<
                              { initial: 10; min: 0; nullable: true; required: false },
                          >;
                      },
                  >,
                  DefaultOptions,
              >,
              {
                  [key: string]: {
                      damage: InitializedType<
                          {
                              initial: undefined;
                              integer: true;
                              min: 0;
                              nullable: true;
                              required: false;
                          },
                      >;
                      drain: InitializedType<
                          {
                              initial: undefined;
                              integer: true;
                              min: 0;
                              nullable: true;
                              required: false;
                          },
                      >;
                      userPenalty: InitializedType<
                          {
                              initial: undefined;
                              integer: true;
                              min: 0;
                              nullable: true;
                              required: false;
                          },
                      >;
                      value: InitializedType<
                          { initial: 10; min: 0; nullable: true; required: false },
                      >;
                  };
              },
              {
                  [key: string]: {
                      damage: InitializedType<
                          {
                              initial: undefined;
                              integer: true;
                              min: 0;
                              nullable: true;
                              required: false;
                          },
                      >;
                      drain: InitializedType<
                          {
                              initial: undefined;
                              integer: true;
                              min: 0;
                              nullable: true;
                              required: false;
                          },
                      >;
                      userPenalty: InitializedType<
                          {
                              initial: undefined;
                              integer: true;
                              min: 0;
                              nullable: true;
                              required: false;
                          },
                      >;
                      value: InitializedType<
                          { initial: 10; min: 0; nullable: true; required: false },
                      >;
                  };
              },
          >;
          altCurrency: TypedObjectField<
              NumberField<
                  { integer: true; min: 0 },
                  AssignmentType<{ integer: true; min: 0 }>,
                  InitializedType<{ integer: true; min: 0 }>,
                  InitializedType<{ integer: true; min: 0 }>,
              >,
              DefaultOptions,
              AssignmentType<
                  NumberField<
                      { integer: true; min: 0 },
                      AssignmentType<{ integer: true; min: 0 }>,
                      InitializedType<{ integer: true; min: 0 }>,
                      InitializedType<{ integer: true; min: 0 }>,
                  >,
                  DefaultOptions,
              >,
              { [key: string]: InitializedType<{ integer: true; min: 0 }> },
              { [key: string]: InitializedType<{ integer: true; min: 0 }> },
          >;
          attributes: SchemaField<
              {
                  ac: SchemaField<
                      {
                          normal: SchemaField<
                              {
                                  ability: StringField<
                                      { blank: true; initial: undefined; required: boolean },
                                      AssignmentType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                      InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                      InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                  >;
                              },
                              DefaultOptions,
                              AssignmentType<
                                  {
                                      ability: StringField<
                                          { blank: true; initial: undefined; required: boolean },
                                          AssignmentType<{ blank: ...; initial: ...; required: ... }>,
                                          InitializedType<{ blank: ...; initial: ...; required: ... }>,
                                          InitializedType<{ blank: ...; initial: ...; required: ... }>,
                                      >;
                                  },
                                  SimpleMerge<DefaultOptions, DefaultOptions>,
                              >,
                              {
                                  ability: InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >;
                              },
                              {
                                  ability: InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >;
                              },
                          >;
                          touch: SchemaField<
                              {
                                  ability: StringField<
                                      { blank: true; initial: undefined; required: boolean },
                                      AssignmentType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                      InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                      InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                  >;
                              },
                              DefaultOptions,
                              AssignmentType<
                                  {
                                      ability: StringField<
                                          { blank: true; initial: undefined; required: boolean },
                                          AssignmentType<{ blank: ...; initial: ...; required: ... }>,
                                          InitializedType<{ blank: ...; initial: ...; required: ... }>,
                                          InitializedType<{ blank: ...; initial: ...; required: ... }>,
                                      >;
                                  },
                                  SimpleMerge<DefaultOptions, DefaultOptions>,
                              >,
                              {
                                  ability: InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >;
                              },
                              {
                                  ability: InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >;
                              },
                          >;
                      },
                      { initial: undefined; required: boolean },
                      AssignmentType<
                          {
                              normal: SchemaField<
                                  {
                                      ability: StringField<
                                          { blank: true; initial: undefined; required: boolean },
                                          AssignmentType<{ blank: ...; initial: ...; required: ... }>,
                                          InitializedType<{ blank: ...; initial: ...; required: ... }>,
                                          InitializedType<{ blank: ...; initial: ...; required: ... }>,
                                      >;
                                  },
                                  DefaultOptions,
                                  AssignmentType<
                                      {
                                          ability: StringField<
                                              { blank: ...; initial: ...; required: ... },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      SimpleMerge<DefaultOptions, DefaultOptions>,
                                  >,
                                  {
                                      ability: InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >;
                                  },
                                  {
                                      ability: InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >;
                                  },
                              >;
                              touch: SchemaField<
                                  {
                                      ability: StringField<
                                          { blank: true; initial: undefined; required: boolean },
                                          AssignmentType<{ blank: ...; initial: ...; required: ... }>,
                                          InitializedType<{ blank: ...; initial: ...; required: ... }>,
                                          InitializedType<{ blank: ...; initial: ...; required: ... }>,
                                      >;
                                  },
                                  DefaultOptions,
                                  AssignmentType<
                                      {
                                          ability: StringField<
                                              { blank: ...; initial: ...; required: ... },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      SimpleMerge<DefaultOptions, DefaultOptions>,
                                  >,
                                  {
                                      ability: InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >;
                                  },
                                  {
                                      ability: InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >;
                                  },
                              >;
                          },
                          SimpleMerge<{ initial: undefined; required: boolean }, DefaultOptions>,
                      >,
                      {
                          normal: {
                              ability: InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >;
                          };
                          touch: {
                              ability: InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >;
                          };
                      },
                      {
                          normal: {
                              ability: InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >;
                          };
                          touch: {
                              ability: InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >;
                          };
                      },
                  >;
                  acNotes: StringField<
                      { blank: true; initial: undefined; required: boolean },
                      AssignmentType<{ blank: true; initial: undefined; required: boolean }>,
                      InitializedType<{ blank: true; initial: undefined; required: boolean }>,
                      InitializedType<{ blank: true; initial: undefined; required: boolean }>,
                  >;
                  attack: SchemaField<
                      {
                          meleeAbility: StringField<
                              { blank: true; initial: undefined; required: boolean },
                              AssignmentType<{ blank: true; initial: undefined; required: boolean }>,
                              InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >,
                              InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >,
                          >;
                          rangedAbility: StringField<
                              { blank: true; initial: undefined; required: boolean },
                              AssignmentType<{ blank: true; initial: undefined; required: boolean }>,
                              InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >,
                              InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >,
                          >;
                      },
                      { initial: undefined; required: boolean },
                      AssignmentType<
                          {
                              meleeAbility: StringField<
                                  { blank: true; initial: undefined; required: boolean },
                                  AssignmentType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                                  InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                                  InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                              >;
                              rangedAbility: StringField<
                                  { blank: true; initial: undefined; required: boolean },
                                  AssignmentType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                                  InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                                  InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                              >;
                          },
                          SimpleMerge<{ initial: undefined; required: boolean }, DefaultOptions>,
                      >,
                      {
                          meleeAbility: InitializedType<
                              { blank: true; initial: undefined; required: boolean },
                          >;
                          rangedAbility: InitializedType<
                              { blank: true; initial: undefined; required: boolean },
                          >;
                      },
                      {
                          meleeAbility: InitializedType<
                              { blank: true; initial: undefined; required: boolean },
                          >;
                          rangedAbility: InitializedType<
                              { blank: true; initial: undefined; required: boolean },
                          >;
                      },
                  >;
                  cmbAbility: StringField<
                      { blank: true; initial: undefined; required: boolean },
                      AssignmentType<{ blank: true; initial: undefined; required: boolean }>,
                      InitializedType<{ blank: true; initial: undefined; required: boolean }>,
                      InitializedType<{ blank: true; initial: undefined; required: boolean }>,
                  >;
                  cmd: SchemaField<
                      {
                          dexAbility: StringField<
                              { blank: true; initial: undefined; required: boolean },
                              AssignmentType<{ blank: true; initial: undefined; required: boolean }>,
                              InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >,
                              InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >,
                          >;
                          strAbility: StringField<
                              { blank: true; initial: undefined; required: boolean },
                              AssignmentType<{ blank: true; initial: undefined; required: boolean }>,
                              InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >,
                              InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >,
                          >;
                      },
                      { initial: undefined; required: boolean },
                      AssignmentType<
                          {
                              dexAbility: StringField<
                                  { blank: true; initial: undefined; required: boolean },
                                  AssignmentType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                                  InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                                  InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                              >;
                              strAbility: StringField<
                                  { blank: true; initial: undefined; required: boolean },
                                  AssignmentType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                                  InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                                  InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                              >;
                          },
                          SimpleMerge<{ initial: undefined; required: boolean }, DefaultOptions>,
                      >,
                      {
                          dexAbility: InitializedType<
                              { blank: true; initial: undefined; required: boolean },
                          >;
                          strAbility: InitializedType<
                              { blank: true; initial: undefined; required: boolean },
                          >;
                      },
                      {
                          dexAbility: InitializedType<
                              { blank: true; initial: undefined; required: boolean },
                          >;
                          strAbility: InitializedType<
                              { blank: true; initial: undefined; required: boolean },
                          >;
                      },
                  >;
                  cmdNotes: StringField<
                      { blank: true; initial: undefined; required: boolean },
                      AssignmentType<{ blank: true; initial: undefined; required: boolean }>,
                      InitializedType<{ blank: true; initial: undefined; required: boolean }>,
                      InitializedType<{ blank: true; initial: undefined; required: boolean }>,
                  >;
                  energyDrain: NumberField<
                      {
                          initial: undefined;
                          integer: true;
                          min: 0;
                          nullable: true;
                          required: boolean;
                      },
                      AssignmentType<
                          {
                              initial: undefined;
                              integer: true;
                              min: 0;
                              nullable: true;
                              required: boolean;
                          },
                      >,
                      InitializedType<
                          {
                              initial: undefined;
                              integer: true;
                              min: 0;
                              nullable: true;
                              required: boolean;
                          },
                      >,
                      InitializedType<
                          {
                              initial: undefined;
                              integer: true;
                              min: 0;
                              nullable: true;
                              required: boolean;
                          },
                      >,
                  >;
                  hp: SchemaField<
                      {
                          nonlethal: NumberField<
                              { initial: number; integer: boolean; min: 0; nullable: boolean },
                              AssignmentType<
                                  { initial: number; integer: boolean; min: 0; nullable: boolean },
                              >,
                              InitializedType<
                                  { initial: number; integer: boolean; min: 0; nullable: boolean },
                              >,
                              InitializedType<
                                  { initial: number; integer: boolean; min: 0; nullable: boolean },
                              >,
                          >;
                          offset: NumberField<
                              { initial: number; integer: boolean; nullable: boolean },
                              AssignmentType<
                                  { initial: number; integer: boolean; nullable: boolean },
                              >,
                              InitializedType<
                                  { initial: number; integer: boolean; nullable: boolean },
                              >,
                              InitializedType<
                                  { initial: number; integer: boolean; nullable: boolean },
                              >,
                          >;
                          temp: NumberField<
                              { initial: number; integer: boolean; min: 0; nullable: boolean },
                              AssignmentType<
                                  { initial: number; integer: boolean; min: 0; nullable: boolean },
                              >,
                              InitializedType<
                                  { initial: number; integer: boolean; min: 0; nullable: boolean },
                              >,
                              InitializedType<
                                  { initial: number; integer: boolean; min: 0; nullable: boolean },
                              >,
                          >;
                      },
                      DefaultOptions,
                      AssignmentType<
                          {
                              nonlethal: NumberField<
                                  { initial: number; integer: boolean; min: 0; nullable: boolean },
                                  AssignmentType<
                                      { initial: number; integer: boolean; min: 0; nullable: boolean },
                                  >,
                                  InitializedType<
                                      { initial: number; integer: boolean; min: 0; nullable: boolean },
                                  >,
                                  InitializedType<
                                      { initial: number; integer: boolean; min: 0; nullable: boolean },
                                  >,
                              >;
                              offset: NumberField<
                                  { initial: number; integer: boolean; nullable: boolean },
                                  AssignmentType<
                                      { initial: number; integer: boolean; nullable: boolean },
                                  >,
                                  InitializedType<
                                      { initial: number; integer: boolean; nullable: boolean },
                                  >,
                                  InitializedType<
                                      { initial: number; integer: boolean; nullable: boolean },
                                  >,
                              >;
                              temp: NumberField<
                                  { initial: number; integer: boolean; min: 0; nullable: boolean },
                                  AssignmentType<
                                      { initial: number; integer: boolean; min: 0; nullable: boolean },
                                  >,
                                  InitializedType<
                                      { initial: number; integer: boolean; min: 0; nullable: boolean },
                                  >,
                                  InitializedType<
                                      { initial: number; integer: boolean; min: 0; nullable: boolean },
                                  >,
                              >;
                          },
                          SimpleMerge<DefaultOptions, DefaultOptions>,
                      >,
                      {
                          nonlethal: InitializedType<
                              { initial: number; integer: boolean; min: 0; nullable: boolean },
                          >;
                          offset: InitializedType<
                              { initial: number; integer: boolean; nullable: boolean },
                          >;
                          temp: InitializedType<
                              { initial: number; integer: boolean; min: 0; nullable: boolean },
                          >;
                      },
                      {
                          nonlethal: InitializedType<
                              { initial: number; integer: boolean; min: 0; nullable: boolean },
                          >;
                          offset: InitializedType<
                              { initial: number; integer: boolean; nullable: boolean },
                          >;
                          temp: InitializedType<
                              { initial: number; integer: boolean; min: 0; nullable: boolean },
                          >;
                      },
                  >;
                  hpAbility: StringField<
                      { blank: true; initial: undefined; required: boolean },
                      AssignmentType<{ blank: true; initial: undefined; required: boolean }>,
                      InitializedType<{ blank: true; initial: undefined; required: boolean }>,
                      InitializedType<{ blank: true; initial: undefined; required: boolean }>,
                  >;
                  init: SchemaField<
                      {
                          ability: StringField<
                              { blank: true; initial: undefined; required: boolean },
                              AssignmentType<{ blank: true; initial: undefined; required: boolean }>,
                              InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >,
                              InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >,
                          >;
                          value: NumberField<
                              { initial: undefined; integer: true; required: boolean },
                              AssignmentType<
                                  { initial: undefined; integer: true; required: boolean },
                              >,
                              InitializedType<
                                  { initial: undefined; integer: true; required: boolean },
                              >,
                              InitializedType<
                                  { initial: undefined; integer: true; required: boolean },
                              >,
                          >;
                      },
                      { initial: undefined; required: boolean },
                      AssignmentType<
                          {
                              ability: StringField<
                                  { blank: true; initial: undefined; required: boolean },
                                  AssignmentType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                                  InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                                  InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                              >;
                              value: NumberField<
                                  { initial: undefined; integer: true; required: boolean },
                                  AssignmentType<
                                      { initial: undefined; integer: true; required: boolean },
                                  >,
                                  InitializedType<
                                      { initial: undefined; integer: true; required: boolean },
                                  >,
                                  InitializedType<
                                      { initial: undefined; integer: true; required: boolean },
                                  >,
                              >;
                          },
                          SimpleMerge<{ initial: undefined; required: boolean }, DefaultOptions>,
                      >,
                      {
                          ability: InitializedType<
                              { blank: true; initial: undefined; required: boolean },
                          >;
                          value: InitializedType<
                              { initial: undefined; integer: true; required: boolean },
                          >;
                      },
                      {
                          ability: InitializedType<
                              { blank: true; initial: undefined; required: boolean },
                          >;
                          value: InitializedType<
                              { initial: undefined; integer: true; required: boolean },
                          >;
                      },
                  >;
                  naturalAC: NumberField<
                      {
                          initial: undefined;
                          integer: boolean;
                          min: 0;
                          nullable: true;
                          required: boolean;
                      },
                      AssignmentType<
                          {
                              initial: undefined;
                              integer: boolean;
                              min: 0;
                              nullable: true;
                              required: boolean;
                          },
                      >,
                      InitializedType<
                          {
                              initial: undefined;
                              integer: boolean;
                              min: 0;
                              nullable: true;
                              required: boolean;
                          },
                      >,
                      InitializedType<
                          {
                              initial: undefined;
                              integer: boolean;
                              min: 0;
                              nullable: true;
                              required: boolean;
                          },
                      >,
                  >;
                  quadruped: BooleanField<
                      { initial: undefined; nullable: true; required: boolean },
                      AssignmentType<
                          SimpleMerge<
                              { initial: undefined; nullable: true; required: boolean },
                              DefaultOptions,
                          >,
                      >,
                      InitializedType<
                          SimpleMerge<
                              { initial: undefined; nullable: true; required: boolean },
                              DefaultOptions,
                          >,
                      >,
                      InitializedType<
                          SimpleMerge<
                              { initial: undefined; nullable: true; required: boolean },
                              DefaultOptions,
                          >,
                      >,
                  >;
                  saveNotes: StringField<
                      { blank: true; initial: undefined; required: boolean },
                      AssignmentType<{ blank: true; initial: undefined; required: boolean }>,
                      InitializedType<{ blank: true; initial: undefined; required: boolean }>,
                      InitializedType<{ blank: true; initial: undefined; required: boolean }>,
                  >;
                  savingThrows: TypedObjectField<
                      SchemaField<
                          {
                              ability: StringField<
                                  { blank: true; initial: undefined; required: boolean },
                                  AssignmentType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                                  InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                                  InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                              >;
                              base: NumberField<
                                  { initial: undefined; integer: true; required: boolean },
                                  AssignmentType<
                                      { initial: undefined; integer: true; required: boolean },
                                  >,
                                  InitializedType<
                                      { initial: undefined; integer: true; required: boolean },
                                  >,
                                  InitializedType<
                                      { initial: undefined; integer: true; required: boolean },
                                  >,
                              >;
                          },
                          DefaultOptions,
                          AssignmentType<
                              {
                                  ability: StringField<
                                      { blank: true; initial: undefined; required: boolean },
                                      AssignmentType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                      InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                      InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                  >;
                                  base: NumberField<
                                      { initial: undefined; integer: true; required: boolean },
                                      AssignmentType<
                                          { initial: undefined; integer: true; required: boolean },
                                      >,
                                      InitializedType<
                                          { initial: undefined; integer: true; required: boolean },
                                      >,
                                      InitializedType<
                                          { initial: undefined; integer: true; required: boolean },
                                      >,
                                  >;
                              },
                              SimpleMerge<DefaultOptions, DefaultOptions>,
                          >,
                          {
                              ability: InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >;
                              base: InitializedType<
                                  { initial: undefined; integer: true; required: boolean },
                              >;
                          },
                          {
                              ability: InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >;
                              base: InitializedType<
                                  { initial: undefined; integer: true; required: boolean },
                              >;
                          },
                      >,
                      DefaultOptions,
                      AssignmentType<
                          SchemaField<
                              {
                                  ability: StringField<
                                      { blank: true; initial: undefined; required: boolean },
                                      AssignmentType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                      InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                      InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                  >;
                                  base: NumberField<
                                      { initial: undefined; integer: true; required: boolean },
                                      AssignmentType<
                                          { initial: undefined; integer: true; required: boolean },
                                      >,
                                      InitializedType<
                                          { initial: undefined; integer: true; required: boolean },
                                      >,
                                      InitializedType<
                                          { initial: undefined; integer: true; required: boolean },
                                      >,
                                  >;
                              },
                              DefaultOptions,
                              AssignmentType<
                                  {
                                      ability: StringField<
                                          { blank: true; initial: undefined; required: boolean },
                                          AssignmentType<{ blank: ...; initial: ...; required: ... }>,
                                          InitializedType<{ blank: ...; initial: ...; required: ... }>,
                                          InitializedType<{ blank: ...; initial: ...; required: ... }>,
                                      >;
                                      base: NumberField<
                                          { initial: undefined; integer: true; required: boolean },
                                          AssignmentType<{ initial: ...; integer: ...; required: ... }>,
                                          InitializedType<{ initial: ...; integer: ...; required: ... }>,
                                          InitializedType<{ initial: ...; integer: ...; required: ... }>,
                                      >;
                                  },
                                  SimpleMerge<DefaultOptions, DefaultOptions>,
                              >,
                              {
                                  ability: InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >;
                                  base: InitializedType<
                                      { initial: undefined; integer: true; required: boolean },
                                  >;
                              },
                              {
                                  ability: InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >;
                                  base: InitializedType<
                                      { initial: undefined; integer: true; required: boolean },
                                  >;
                              },
                          >,
                          DefaultOptions,
                      >,
                      {
                          [key: string]: {
                              ability: InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >;
                              base: InitializedType<
                                  { initial: undefined; integer: true; required: boolean },
                              >;
                          };
                      },
                      {
                          [key: string]: {
                              ability: InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >;
                              base: InitializedType<
                                  { initial: undefined; integer: true; required: boolean },
                              >;
                          };
                      },
                  >;
                  speed: SchemaField<
                      {
                          burrow: SchemaField<
                              {
                                  base: NumberField<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                      AssignmentType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >,
                                      InitializedType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >,
                                      InitializedType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >,
                                  >;
                              },
                              { initial: undefined; required: boolean },
                              AssignmentType<
                                  {
                                      base: NumberField<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                          AssignmentType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                      >;
                                  },
                                  SimpleMerge<
                                      { initial: undefined; required: boolean },
                                      DefaultOptions,
                                  >,
                              >,
                              {
                                  base: InitializedType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                  >;
                              },
                              {
                                  base: InitializedType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                  >;
                              },
                          >;
                          climb: SchemaField<
                              {
                                  base: NumberField<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                      AssignmentType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >,
                                      InitializedType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >,
                                      InitializedType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >,
                                  >;
                              },
                              { initial: undefined; required: boolean },
                              AssignmentType<
                                  {
                                      base: NumberField<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                          AssignmentType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                      >;
                                  },
                                  SimpleMerge<
                                      { initial: undefined; required: boolean },
                                      DefaultOptions,
                                  >,
                              >,
                              {
                                  base: InitializedType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                  >;
                              },
                              {
                                  base: InitializedType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                  >;
                              },
                          >;
                          fly: SchemaField<
                              {
                                  base: NumberField<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                      AssignmentType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >,
                                      InitializedType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >,
                                      InitializedType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >,
                                  >;
                                  maneuverability: StringField<
                                      { choices: () => (...)[]; initial: undefined; required: boolean },
                                      AssignmentType<
                                          { choices: () => ...; initial: undefined; required: boolean },
                                      >,
                                      InitializedType<
                                          { choices: () => ...; initial: undefined; required: boolean },
                                      >,
                                      InitializedType<
                                          { choices: () => ...; initial: undefined; required: boolean },
                                      >,
                                  >;
                              },
                              { initial: undefined; required: boolean },
                              AssignmentType<
                                  {
                                      base: NumberField<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                          AssignmentType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                      >;
                                      maneuverability: StringField<
                                          { choices: () => ...; initial: undefined; required: boolean },
                                          AssignmentType<{ choices: ...; initial: ...; required: ... }>,
                                          InitializedType<{ choices: ...; initial: ...; required: ... }>,
                                          InitializedType<{ choices: ...; initial: ...; required: ... }>,
                                      >;
                                  },
                                  SimpleMerge<
                                      { initial: undefined; required: boolean },
                                      DefaultOptions,
                                  >,
                              >,
                              {
                                  base: InitializedType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                  >;
                                  maneuverability: InitializedType<
                                      { choices: () => (...)[]; initial: undefined; required: boolean },
                                  >;
                              },
                              {
                                  base: InitializedType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                  >;
                                  maneuverability: InitializedType<
                                      { choices: () => (...)[]; initial: undefined; required: boolean },
                                  >;
                              },
                          >;
                          land: SchemaField<
                              {
                                  base: NumberField<
                                      {
                                          initial: 30;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                      AssignmentType<
                                          {
                                              initial: 30;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >,
                                      InitializedType<
                                          {
                                              initial: 30;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >,
                                      InitializedType<
                                          {
                                              initial: 30;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >,
                                  >;
                              },
                              { initial: undefined; required: boolean },
                              AssignmentType<
                                  {
                                      base: NumberField<
                                          {
                                              initial: 30;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                          AssignmentType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                      >;
                                  },
                                  SimpleMerge<
                                      { initial: undefined; required: boolean },
                                      DefaultOptions,
                                  >,
                              >,
                              {
                                  base: InitializedType<
                                      {
                                          initial: 30;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                  >;
                              },
                              {
                                  base: InitializedType<
                                      {
                                          initial: 30;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                  >;
                              },
                          >;
                          swim: SchemaField<
                              {
                                  base: NumberField<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                      AssignmentType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >,
                                      InitializedType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >,
                                      InitializedType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >,
                                  >;
                              },
                              { initial: undefined; required: boolean },
                              AssignmentType<
                                  {
                                      base: NumberField<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                          AssignmentType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                      >;
                                  },
                                  SimpleMerge<
                                      { initial: undefined; required: boolean },
                                      DefaultOptions,
                                  >,
                              >,
                              {
                                  base: InitializedType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                  >;
                              },
                              {
                                  base: InitializedType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                  >;
                              },
                          >;
                      },
                      DefaultOptions,
                      AssignmentType<
                          {
                              burrow: SchemaField<
                                  {
                                      base: NumberField<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                          AssignmentType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                      >;
                                  },
                                  { initial: undefined; required: boolean },
                                  AssignmentType<
                                      {
                                          base: NumberField<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      SimpleMerge<
                                          { initial: undefined; required: boolean },
                                          DefaultOptions,
                                      >,
                                  >,
                                  {
                                      base: InitializedType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >;
                                  },
                                  {
                                      base: InitializedType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >;
                                  },
                              >;
                              climb: SchemaField<
                                  {
                                      base: NumberField<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                          AssignmentType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                      >;
                                  },
                                  { initial: undefined; required: boolean },
                                  AssignmentType<
                                      {
                                          base: NumberField<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      SimpleMerge<
                                          { initial: undefined; required: boolean },
                                          DefaultOptions,
                                      >,
                                  >,
                                  {
                                      base: InitializedType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >;
                                  },
                                  {
                                      base: InitializedType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >;
                                  },
                              >;
                              fly: SchemaField<
                                  {
                                      base: NumberField<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                          AssignmentType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                      >;
                                      maneuverability: StringField<
                                          { choices: () => ...; initial: undefined; required: boolean },
                                          AssignmentType<{ choices: ...; initial: ...; required: ... }>,
                                          InitializedType<{ choices: ...; initial: ...; required: ... }>,
                                          InitializedType<{ choices: ...; initial: ...; required: ... }>,
                                      >;
                                  },
                                  { initial: undefined; required: boolean },
                                  AssignmentType<
                                      {
                                          base: NumberField<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                          maneuverability: StringField<
                                              { choices: ...; initial: ...; required: ... },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      SimpleMerge<
                                          { initial: undefined; required: boolean },
                                          DefaultOptions,
                                      >,
                                  >,
                                  {
                                      base: InitializedType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >;
                                      maneuverability: InitializedType<
                                          { choices: () => ...; initial: undefined; required: boolean },
                                      >;
                                  },
                                  {
                                      base: InitializedType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >;
                                      maneuverability: InitializedType<
                                          { choices: () => ...; initial: undefined; required: boolean },
                                      >;
                                  },
                              >;
                              land: SchemaField<
                                  {
                                      base: NumberField<
                                          {
                                              initial: 30;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                          AssignmentType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                      >;
                                  },
                                  { initial: undefined; required: boolean },
                                  AssignmentType<
                                      {
                                          base: NumberField<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      SimpleMerge<
                                          { initial: undefined; required: boolean },
                                          DefaultOptions,
                                      >,
                                  >,
                                  {
                                      base: InitializedType<
                                          {
                                              initial: 30;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >;
                                  },
                                  {
                                      base: InitializedType<
                                          {
                                              initial: 30;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >;
                                  },
                              >;
                              swim: SchemaField<
                                  {
                                      base: NumberField<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                          AssignmentType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                      >;
                                  },
                                  { initial: undefined; required: boolean },
                                  AssignmentType<
                                      {
                                          base: NumberField<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      SimpleMerge<
                                          { initial: undefined; required: boolean },
                                          DefaultOptions,
                                      >,
                                  >,
                                  {
                                      base: InitializedType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >;
                                  },
                                  {
                                      base: InitializedType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >;
                                  },
                              >;
                          },
                          SimpleMerge<DefaultOptions, DefaultOptions>,
                      >,
                      {
                          burrow: {
                              base: InitializedType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: boolean;
                                  },
                              >;
                          };
                          climb: {
                              base: InitializedType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: boolean;
                                  },
                              >;
                          };
                          fly: {
                              base: InitializedType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: boolean;
                                  },
                              >;
                              maneuverability: InitializedType<
                                  { choices: () => string[]; initial: undefined; required: boolean },
                              >;
                          };
                          land: {
                              base: InitializedType<
                                  {
                                      initial: 30;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: boolean;
                                  },
                              >;
                          };
                          swim: {
                              base: InitializedType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: boolean;
                                  },
                              >;
                          };
                      },
                      {
                          burrow: {
                              base: InitializedType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: boolean;
                                  },
                              >;
                          };
                          climb: {
                              base: InitializedType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: boolean;
                                  },
                              >;
                          };
                          fly: {
                              base: InitializedType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: boolean;
                                  },
                              >;
                              maneuverability: InitializedType<
                                  { choices: () => string[]; initial: undefined; required: boolean },
                              >;
                          };
                          land: {
                              base: InitializedType<
                                  {
                                      initial: 30;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: boolean;
                                  },
                              >;
                          };
                          swim: {
                              base: InitializedType<
                                  {
                                      initial: undefined;
                                      integer: true;
                                      min: 0;
                                      nullable: true;
                                      required: boolean;
                                  },
                              >;
                          };
                      },
                  >;
                  sr: SchemaField<
                      { formula: FormulaField },
                      { initial: undefined; required: boolean },
                      AssignmentType<
                          { formula: FormulaField },
                          SimpleMerge<{ initial: undefined; required: boolean }, DefaultOptions>,
                      >,
                      { formula: InitializedType<DefaultOptions> },
                      { formula: InitializedType<DefaultOptions> },
                  >;
                  srNotes: StringField<
                      { blank: true; initial: undefined; required: boolean },
                      AssignmentType<{ blank: true; initial: undefined; required: boolean }>,
                      InitializedType<{ blank: true; initial: undefined; required: boolean }>,
                      InitializedType<{ blank: true; initial: undefined; required: boolean }>,
                  >;
                  vigor: SchemaField<
                      {
                          offset: NumberField<
                              { initial: number; integer: boolean; nullable: boolean },
                              AssignmentType<
                                  { initial: number; integer: boolean; nullable: boolean },
                              >,
                              InitializedType<
                                  { initial: number; integer: boolean; nullable: boolean },
                              >,
                              InitializedType<
                                  { initial: number; integer: boolean; nullable: boolean },
                              >,
                          >;
                          temp: NumberField<
                              { initial: number; integer: boolean; min: 0; nullable: boolean },
                              AssignmentType<
                                  { initial: number; integer: boolean; min: 0; nullable: boolean },
                              >,
                              InitializedType<
                                  { initial: number; integer: boolean; min: 0; nullable: boolean },
                              >,
                              InitializedType<
                                  { initial: number; integer: boolean; min: 0; nullable: boolean },
                              >,
                          >;
                      },
                      DefaultOptions,
                      AssignmentType<
                          {
                              offset: NumberField<
                                  { initial: number; integer: boolean; nullable: boolean },
                                  AssignmentType<
                                      { initial: number; integer: boolean; nullable: boolean },
                                  >,
                                  InitializedType<
                                      { initial: number; integer: boolean; nullable: boolean },
                                  >,
                                  InitializedType<
                                      { initial: number; integer: boolean; nullable: boolean },
                                  >,
                              >;
                              temp: NumberField<
                                  { initial: number; integer: boolean; min: 0; nullable: boolean },
                                  AssignmentType<
                                      { initial: number; integer: boolean; min: 0; nullable: boolean },
                                  >,
                                  InitializedType<
                                      { initial: number; integer: boolean; min: 0; nullable: boolean },
                                  >,
                                  InitializedType<
                                      { initial: number; integer: boolean; min: 0; nullable: boolean },
                                  >,
                              >;
                          },
                          SimpleMerge<DefaultOptions, DefaultOptions>,
                      >,
                      {
                          offset: InitializedType<
                              { initial: number; integer: boolean; nullable: boolean },
                          >;
                          temp: InitializedType<
                              { initial: number; integer: boolean; min: 0; nullable: boolean },
                          >;
                      },
                      {
                          offset: InitializedType<
                              { initial: number; integer: boolean; nullable: boolean },
                          >;
                          temp: InitializedType<
                              { initial: number; integer: boolean; min: 0; nullable: boolean },
                          >;
                      },
                  >;
                  wounds: SchemaField<
                      {
                          offset: NumberField<
                              { initial: number; integer: boolean; nullable: boolean },
                              AssignmentType<
                                  { initial: number; integer: boolean; nullable: boolean },
                              >,
                              InitializedType<
                                  { initial: number; integer: boolean; nullable: boolean },
                              >,
                              InitializedType<
                                  { initial: number; integer: boolean; nullable: boolean },
                              >,
                          >;
                      },
                      DefaultOptions,
                      AssignmentType<
                          {
                              offset: NumberField<
                                  { initial: number; integer: boolean; nullable: boolean },
                                  AssignmentType<
                                      { initial: number; integer: boolean; nullable: boolean },
                                  >,
                                  InitializedType<
                                      { initial: number; integer: boolean; nullable: boolean },
                                  >,
                                  InitializedType<
                                      { initial: number; integer: boolean; nullable: boolean },
                                  >,
                              >;
                          },
                          SimpleMerge<DefaultOptions, DefaultOptions>,
                      >,
                      {
                          offset: InitializedType<
                              { initial: number; integer: boolean; nullable: boolean },
                          >;
                      },
                      {
                          offset: InitializedType<
                              { initial: number; integer: boolean; nullable: boolean },
                          >;
                      },
                  >;
              },
              DefaultOptions,
              AssignmentType<
                  {
                      ac: SchemaField<
                          {
                              normal: SchemaField<
                                  {
                                      ability: StringField<
                                          { blank: true; initial: undefined; required: boolean },
                                          AssignmentType<{ blank: ...; initial: ...; required: ... }>,
                                          InitializedType<{ blank: ...; initial: ...; required: ... }>,
                                          InitializedType<{ blank: ...; initial: ...; required: ... }>,
                                      >;
                                  },
                                  DefaultOptions,
                                  AssignmentType<
                                      {
                                          ability: StringField<
                                              { blank: ...; initial: ...; required: ... },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      SimpleMerge<DefaultOptions, DefaultOptions>,
                                  >,
                                  {
                                      ability: InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >;
                                  },
                                  {
                                      ability: InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >;
                                  },
                              >;
                              touch: SchemaField<
                                  {
                                      ability: StringField<
                                          { blank: true; initial: undefined; required: boolean },
                                          AssignmentType<{ blank: ...; initial: ...; required: ... }>,
                                          InitializedType<{ blank: ...; initial: ...; required: ... }>,
                                          InitializedType<{ blank: ...; initial: ...; required: ... }>,
                                      >;
                                  },
                                  DefaultOptions,
                                  AssignmentType<
                                      {
                                          ability: StringField<
                                              { blank: ...; initial: ...; required: ... },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      SimpleMerge<DefaultOptions, DefaultOptions>,
                                  >,
                                  {
                                      ability: InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >;
                                  },
                                  {
                                      ability: InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >;
                                  },
                              >;
                          },
                          { initial: undefined; required: boolean },
                          AssignmentType<
                              {
                                  normal: SchemaField<
                                      {
                                          ability: StringField<
                                              { blank: ...; initial: ...; required: ... },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      DefaultOptions,
                                      AssignmentType<
                                          { ability: StringField<(...), (...), (...), (...)> },
                                          SimpleMerge<DefaultOptions, DefaultOptions>,
                                      >,
                                      {
                                          ability: InitializedType<
                                              { blank: ...; initial: ...; required: ... },
                                          >;
                                      },
                                      {
                                          ability: InitializedType<
                                              { blank: ...; initial: ...; required: ... },
                                          >;
                                      },
                                  >;
                                  touch: SchemaField<
                                      {
                                          ability: StringField<
                                              { blank: ...; initial: ...; required: ... },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      DefaultOptions,
                                      AssignmentType<
                                          { ability: StringField<(...), (...), (...), (...)> },
                                          SimpleMerge<DefaultOptions, DefaultOptions>,
                                      >,
                                      {
                                          ability: InitializedType<
                                              { blank: ...; initial: ...; required: ... },
                                          >;
                                      },
                                      {
                                          ability: InitializedType<
                                              { blank: ...; initial: ...; required: ... },
                                          >;
                                      },
                                  >;
                              },
                              SimpleMerge<{ initial: undefined; required: boolean }, DefaultOptions>,
                          >,
                          {
                              normal: {
                                  ability: InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >;
                              };
                              touch: {
                                  ability: InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >;
                              };
                          },
                          {
                              normal: {
                                  ability: InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >;
                              };
                              touch: {
                                  ability: InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >;
                              };
                          },
                      >;
                      acNotes: StringField<
                          { blank: true; initial: undefined; required: boolean },
                          AssignmentType<{ blank: true; initial: undefined; required: boolean }>,
                          InitializedType<{ blank: true; initial: undefined; required: boolean }>,
                          InitializedType<{ blank: true; initial: undefined; required: boolean }>,
                      >;
                      attack: SchemaField<
                          {
                              meleeAbility: StringField<
                                  { blank: true; initial: undefined; required: boolean },
                                  AssignmentType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                                  InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                                  InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                              >;
                              rangedAbility: StringField<
                                  { blank: true; initial: undefined; required: boolean },
                                  AssignmentType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                                  InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                                  InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                              >;
                          },
                          { initial: undefined; required: boolean },
                          AssignmentType<
                              {
                                  meleeAbility: StringField<
                                      { blank: true; initial: undefined; required: boolean },
                                      AssignmentType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                      InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                      InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                  >;
                                  rangedAbility: StringField<
                                      { blank: true; initial: undefined; required: boolean },
                                      AssignmentType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                      InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                      InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                  >;
                              },
                              SimpleMerge<{ initial: undefined; required: boolean }, DefaultOptions>,
                          >,
                          {
                              meleeAbility: InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >;
                              rangedAbility: InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >;
                          },
                          {
                              meleeAbility: InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >;
                              rangedAbility: InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >;
                          },
                      >;
                      cmbAbility: StringField<
                          { blank: true; initial: undefined; required: boolean },
                          AssignmentType<{ blank: true; initial: undefined; required: boolean }>,
                          InitializedType<{ blank: true; initial: undefined; required: boolean }>,
                          InitializedType<{ blank: true; initial: undefined; required: boolean }>,
                      >;
                      cmd: SchemaField<
                          {
                              dexAbility: StringField<
                                  { blank: true; initial: undefined; required: boolean },
                                  AssignmentType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                                  InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                                  InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                              >;
                              strAbility: StringField<
                                  { blank: true; initial: undefined; required: boolean },
                                  AssignmentType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                                  InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                                  InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                              >;
                          },
                          { initial: undefined; required: boolean },
                          AssignmentType<
                              {
                                  dexAbility: StringField<
                                      { blank: true; initial: undefined; required: boolean },
                                      AssignmentType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                      InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                      InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                  >;
                                  strAbility: StringField<
                                      { blank: true; initial: undefined; required: boolean },
                                      AssignmentType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                      InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                      InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                  >;
                              },
                              SimpleMerge<{ initial: undefined; required: boolean }, DefaultOptions>,
                          >,
                          {
                              dexAbility: InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >;
                              strAbility: InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >;
                          },
                          {
                              dexAbility: InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >;
                              strAbility: InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >;
                          },
                      >;
                      cmdNotes: StringField<
                          { blank: true; initial: undefined; required: boolean },
                          AssignmentType<{ blank: true; initial: undefined; required: boolean }>,
                          InitializedType<{ blank: true; initial: undefined; required: boolean }>,
                          InitializedType<{ blank: true; initial: undefined; required: boolean }>,
                      >;
                      energyDrain: NumberField<
                          {
                              initial: undefined;
                              integer: true;
                              min: 0;
                              nullable: true;
                              required: boolean;
                          },
                          AssignmentType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: boolean;
                              },
                          >,
                          InitializedType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: boolean;
                              },
                          >,
                          InitializedType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: boolean;
                              },
                          >,
                      >;
                      hp: SchemaField<
                          {
                              nonlethal: NumberField<
                                  { initial: number; integer: boolean; min: 0; nullable: boolean },
                                  AssignmentType<
                                      { initial: number; integer: boolean; min: 0; nullable: boolean },
                                  >,
                                  InitializedType<
                                      { initial: number; integer: boolean; min: 0; nullable: boolean },
                                  >,
                                  InitializedType<
                                      { initial: number; integer: boolean; min: 0; nullable: boolean },
                                  >,
                              >;
                              offset: NumberField<
                                  { initial: number; integer: boolean; nullable: boolean },
                                  AssignmentType<
                                      { initial: number; integer: boolean; nullable: boolean },
                                  >,
                                  InitializedType<
                                      { initial: number; integer: boolean; nullable: boolean },
                                  >,
                                  InitializedType<
                                      { initial: number; integer: boolean; nullable: boolean },
                                  >,
                              >;
                              temp: NumberField<
                                  { initial: number; integer: boolean; min: 0; nullable: boolean },
                                  AssignmentType<
                                      { initial: number; integer: boolean; min: 0; nullable: boolean },
                                  >,
                                  InitializedType<
                                      { initial: number; integer: boolean; min: 0; nullable: boolean },
                                  >,
                                  InitializedType<
                                      { initial: number; integer: boolean; min: 0; nullable: boolean },
                                  >,
                              >;
                          },
                          DefaultOptions,
                          AssignmentType<
                              {
                                  nonlethal: NumberField<
                                      { initial: number; integer: boolean; min: 0; nullable: boolean },
                                      AssignmentType<
                                          { initial: number; integer: boolean; min: 0; nullable: boolean },
                                      >,
                                      InitializedType<
                                          { initial: number; integer: boolean; min: 0; nullable: boolean },
                                      >,
                                      InitializedType<
                                          { initial: number; integer: boolean; min: 0; nullable: boolean },
                                      >,
                                  >;
                                  offset: NumberField<
                                      { initial: number; integer: boolean; nullable: boolean },
                                      AssignmentType<
                                          { initial: number; integer: boolean; nullable: boolean },
                                      >,
                                      InitializedType<
                                          { initial: number; integer: boolean; nullable: boolean },
                                      >,
                                      InitializedType<
                                          { initial: number; integer: boolean; nullable: boolean },
                                      >,
                                  >;
                                  temp: NumberField<
                                      { initial: number; integer: boolean; min: 0; nullable: boolean },
                                      AssignmentType<
                                          { initial: number; integer: boolean; min: 0; nullable: boolean },
                                      >,
                                      InitializedType<
                                          { initial: number; integer: boolean; min: 0; nullable: boolean },
                                      >,
                                      InitializedType<
                                          { initial: number; integer: boolean; min: 0; nullable: boolean },
                                      >,
                                  >;
                              },
                              SimpleMerge<DefaultOptions, DefaultOptions>,
                          >,
                          {
                              nonlethal: InitializedType<
                                  { initial: number; integer: boolean; min: 0; nullable: boolean },
                              >;
                              offset: InitializedType<
                                  { initial: number; integer: boolean; nullable: boolean },
                              >;
                              temp: InitializedType<
                                  { initial: number; integer: boolean; min: 0; nullable: boolean },
                              >;
                          },
                          {
                              nonlethal: InitializedType<
                                  { initial: number; integer: boolean; min: 0; nullable: boolean },
                              >;
                              offset: InitializedType<
                                  { initial: number; integer: boolean; nullable: boolean },
                              >;
                              temp: InitializedType<
                                  { initial: number; integer: boolean; min: 0; nullable: boolean },
                              >;
                          },
                      >;
                      hpAbility: StringField<
                          { blank: true; initial: undefined; required: boolean },
                          AssignmentType<{ blank: true; initial: undefined; required: boolean }>,
                          InitializedType<{ blank: true; initial: undefined; required: boolean }>,
                          InitializedType<{ blank: true; initial: undefined; required: boolean }>,
                      >;
                      init: SchemaField<
                          {
                              ability: StringField<
                                  { blank: true; initial: undefined; required: boolean },
                                  AssignmentType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                                  InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                                  InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >,
                              >;
                              value: NumberField<
                                  { initial: undefined; integer: true; required: boolean },
                                  AssignmentType<
                                      { initial: undefined; integer: true; required: boolean },
                                  >,
                                  InitializedType<
                                      { initial: undefined; integer: true; required: boolean },
                                  >,
                                  InitializedType<
                                      { initial: undefined; integer: true; required: boolean },
                                  >,
                              >;
                          },
                          { initial: undefined; required: boolean },
                          AssignmentType<
                              {
                                  ability: StringField<
                                      { blank: true; initial: undefined; required: boolean },
                                      AssignmentType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                      InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                      InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                  >;
                                  value: NumberField<
                                      { initial: undefined; integer: true; required: boolean },
                                      AssignmentType<
                                          { initial: undefined; integer: true; required: boolean },
                                      >,
                                      InitializedType<
                                          { initial: undefined; integer: true; required: boolean },
                                      >,
                                      InitializedType<
                                          { initial: undefined; integer: true; required: boolean },
                                      >,
                                  >;
                              },
                              SimpleMerge<{ initial: undefined; required: boolean }, DefaultOptions>,
                          >,
                          {
                              ability: InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >;
                              value: InitializedType<
                                  { initial: undefined; integer: true; required: boolean },
                              >;
                          },
                          {
                              ability: InitializedType<
                                  { blank: true; initial: undefined; required: boolean },
                              >;
                              value: InitializedType<
                                  { initial: undefined; integer: true; required: boolean },
                              >;
                          },
                      >;
                      naturalAC: NumberField<
                          {
                              initial: undefined;
                              integer: boolean;
                              min: 0;
                              nullable: true;
                              required: boolean;
                          },
                          AssignmentType<
                              {
                                  initial: undefined;
                                  integer: boolean;
                                  min: 0;
                                  nullable: true;
                                  required: boolean;
                              },
                          >,
                          InitializedType<
                              {
                                  initial: undefined;
                                  integer: boolean;
                                  min: 0;
                                  nullable: true;
                                  required: boolean;
                              },
                          >,
                          InitializedType<
                              {
                                  initial: undefined;
                                  integer: boolean;
                                  min: 0;
                                  nullable: true;
                                  required: boolean;
                              },
                          >,
                      >;
                      quadruped: BooleanField<
                          { initial: undefined; nullable: true; required: boolean },
                          AssignmentType<
                              SimpleMerge<
                                  { initial: undefined; nullable: true; required: boolean },
                                  DefaultOptions,
                              >,
                          >,
                          InitializedType<
                              SimpleMerge<
                                  { initial: undefined; nullable: true; required: boolean },
                                  DefaultOptions,
                              >,
                          >,
                          InitializedType<
                              SimpleMerge<
                                  { initial: undefined; nullable: true; required: boolean },
                                  DefaultOptions,
                              >,
                          >,
                      >;
                      saveNotes: StringField<
                          { blank: true; initial: undefined; required: boolean },
                          AssignmentType<{ blank: true; initial: undefined; required: boolean }>,
                          InitializedType<{ blank: true; initial: undefined; required: boolean }>,
                          InitializedType<{ blank: true; initial: undefined; required: boolean }>,
                      >;
                      savingThrows: TypedObjectField<
                          SchemaField<
                              {
                                  ability: StringField<
                                      { blank: true; initial: undefined; required: boolean },
                                      AssignmentType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                      InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                      InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >,
                                  >;
                                  base: NumberField<
                                      { initial: undefined; integer: true; required: boolean },
                                      AssignmentType<
                                          { initial: undefined; integer: true; required: boolean },
                                      >,
                                      InitializedType<
                                          { initial: undefined; integer: true; required: boolean },
                                      >,
                                      InitializedType<
                                          { initial: undefined; integer: true; required: boolean },
                                      >,
                                  >;
                              },
                              DefaultOptions,
                              AssignmentType<
                                  {
                                      ability: StringField<
                                          { blank: true; initial: undefined; required: boolean },
                                          AssignmentType<{ blank: ...; initial: ...; required: ... }>,
                                          InitializedType<{ blank: ...; initial: ...; required: ... }>,
                                          InitializedType<{ blank: ...; initial: ...; required: ... }>,
                                      >;
                                      base: NumberField<
                                          { initial: undefined; integer: true; required: boolean },
                                          AssignmentType<{ initial: ...; integer: ...; required: ... }>,
                                          InitializedType<{ initial: ...; integer: ...; required: ... }>,
                                          InitializedType<{ initial: ...; integer: ...; required: ... }>,
                                      >;
                                  },
                                  SimpleMerge<DefaultOptions, DefaultOptions>,
                              >,
                              {
                                  ability: InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >;
                                  base: InitializedType<
                                      { initial: undefined; integer: true; required: boolean },
                                  >;
                              },
                              {
                                  ability: InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >;
                                  base: InitializedType<
                                      { initial: undefined; integer: true; required: boolean },
                                  >;
                              },
                          >,
                          DefaultOptions,
                          AssignmentType<
                              SchemaField<
                                  {
                                      ability: StringField<
                                          { blank: true; initial: undefined; required: boolean },
                                          AssignmentType<{ blank: ...; initial: ...; required: ... }>,
                                          InitializedType<{ blank: ...; initial: ...; required: ... }>,
                                          InitializedType<{ blank: ...; initial: ...; required: ... }>,
                                      >;
                                      base: NumberField<
                                          { initial: undefined; integer: true; required: boolean },
                                          AssignmentType<{ initial: ...; integer: ...; required: ... }>,
                                          InitializedType<{ initial: ...; integer: ...; required: ... }>,
                                          InitializedType<{ initial: ...; integer: ...; required: ... }>,
                                      >;
                                  },
                                  DefaultOptions,
                                  AssignmentType<
                                      {
                                          ability: StringField<
                                              { blank: ...; initial: ...; required: ... },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                          base: NumberField<
                                              { initial: ...; integer: ...; required: ... },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      SimpleMerge<DefaultOptions, DefaultOptions>,
                                  >,
                                  {
                                      ability: InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >;
                                      base: InitializedType<
                                          { initial: undefined; integer: true; required: boolean },
                                      >;
                                  },
                                  {
                                      ability: InitializedType<
                                          { blank: true; initial: undefined; required: boolean },
                                      >;
                                      base: InitializedType<
                                          { initial: undefined; integer: true; required: boolean },
                                      >;
                                  },
                              >,
                              DefaultOptions,
                          >,
                          {
                              [key: string]: {
                                  ability: InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >;
                                  base: InitializedType<
                                      { initial: undefined; integer: true; required: boolean },
                                  >;
                              };
                          },
                          {
                              [key: string]: {
                                  ability: InitializedType<
                                      { blank: true; initial: undefined; required: boolean },
                                  >;
                                  base: InitializedType<
                                      { initial: undefined; integer: true; required: boolean },
                                  >;
                              };
                          },
                      >;
                      speed: SchemaField<
                          {
                              burrow: SchemaField<
                                  {
                                      base: NumberField<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                          AssignmentType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                      >;
                                  },
                                  { initial: undefined; required: boolean },
                                  AssignmentType<
                                      {
                                          base: NumberField<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      SimpleMerge<
                                          { initial: undefined; required: boolean },
                                          DefaultOptions,
                                      >,
                                  >,
                                  {
                                      base: InitializedType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >;
                                  },
                                  {
                                      base: InitializedType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >;
                                  },
                              >;
                              climb: SchemaField<
                                  {
                                      base: NumberField<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                          AssignmentType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                      >;
                                  },
                                  { initial: undefined; required: boolean },
                                  AssignmentType<
                                      {
                                          base: NumberField<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      SimpleMerge<
                                          { initial: undefined; required: boolean },
                                          DefaultOptions,
                                      >,
                                  >,
                                  {
                                      base: InitializedType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >;
                                  },
                                  {
                                      base: InitializedType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >;
                                  },
                              >;
                              fly: SchemaField<
                                  {
                                      base: NumberField<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                          AssignmentType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                      >;
                                      maneuverability: StringField<
                                          { choices: () => ...; initial: undefined; required: boolean },
                                          AssignmentType<{ choices: ...; initial: ...; required: ... }>,
                                          InitializedType<{ choices: ...; initial: ...; required: ... }>,
                                          InitializedType<{ choices: ...; initial: ...; required: ... }>,
                                      >;
                                  },
                                  { initial: undefined; required: boolean },
                                  AssignmentType<
                                      {
                                          base: NumberField<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                          maneuverability: StringField<
                                              { choices: ...; initial: ...; required: ... },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      SimpleMerge<
                                          { initial: undefined; required: boolean },
                                          DefaultOptions,
                                      >,
                                  >,
                                  {
                                      base: InitializedType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >;
                                      maneuverability: InitializedType<
                                          { choices: () => ...; initial: undefined; required: boolean },
                                      >;
                                  },
                                  {
                                      base: InitializedType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >;
                                      maneuverability: InitializedType<
                                          { choices: () => ...; initial: undefined; required: boolean },
                                      >;
                                  },
                              >;
                              land: SchemaField<
                                  {
                                      base: NumberField<
                                          {
                                              initial: 30;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                          AssignmentType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                      >;
                                  },
                                  { initial: undefined; required: boolean },
                                  AssignmentType<
                                      {
                                          base: NumberField<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      SimpleMerge<
                                          { initial: undefined; required: boolean },
                                          DefaultOptions,
                                      >,
                                  >,
                                  {
                                      base: InitializedType<
                                          {
                                              initial: 30;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >;
                                  },
                                  {
                                      base: InitializedType<
                                          {
                                              initial: 30;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >;
                                  },
                              >;
                              swim: SchemaField<
                                  {
                                      base: NumberField<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                          AssignmentType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                          InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >,
                                      >;
                                  },
                                  { initial: undefined; required: boolean },
                                  AssignmentType<
                                      {
                                          base: NumberField<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      SimpleMerge<
                                          { initial: undefined; required: boolean },
                                          DefaultOptions,
                                      >,
                                  >,
                                  {
                                      base: InitializedType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >;
                                  },
                                  {
                                      base: InitializedType<
                                          {
                                              initial: undefined;
                                              integer: true;
                                              min: 0;
                                              nullable: true;
                                              required: boolean;
                                          },
                                      >;
                                  },
                              >;
                          },
                          DefaultOptions,
                          AssignmentType<
                              {
                                  burrow: SchemaField<
                                      {
                                          base: NumberField<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      { initial: undefined; required: boolean },
                                      AssignmentType<
                                          { base: NumberField<(...), (...), (...), (...)> },
                                          SimpleMerge<{ initial: ...; required: ... }, DefaultOptions>,
                                      >,
                                      {
                                          base: InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >;
                                      },
                                      {
                                          base: InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >;
                                      },
                                  >;
                                  climb: SchemaField<
                                      {
                                          base: NumberField<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      { initial: undefined; required: boolean },
                                      AssignmentType<
                                          { base: NumberField<(...), (...), (...), (...)> },
                                          SimpleMerge<{ initial: ...; required: ... }, DefaultOptions>,
                                      >,
                                      {
                                          base: InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >;
                                      },
                                      {
                                          base: InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >;
                                      },
                                  >;
                                  fly: SchemaField<
                                      {
                                          base: NumberField<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                          maneuverability: StringField<
                                              { choices: ...; initial: ...; required: ... },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      { initial: undefined; required: boolean },
                                      AssignmentType<
                                          {
                                              base: NumberField<(...), (...), (...), (...)>;
                                              maneuverability: StringField<(...), (...), (...), (...)>;
                                          },
                                          SimpleMerge<{ initial: ...; required: ... }, DefaultOptions>,
                                      >,
                                      {
                                          base: InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >;
                                          maneuverability: InitializedType<
                                              { choices: ...; initial: ...; required: ... },
                                          >;
                                      },
                                      {
                                          base: InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >;
                                          maneuverability: InitializedType<
                                              { choices: ...; initial: ...; required: ... },
                                          >;
                                      },
                                  >;
                                  land: SchemaField<
                                      {
                                          base: NumberField<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      { initial: undefined; required: boolean },
                                      AssignmentType<
                                          { base: NumberField<(...), (...), (...), (...)> },
                                          SimpleMerge<{ initial: ...; required: ... }, DefaultOptions>,
                                      >,
                                      {
                                          base: InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >;
                                      },
                                      {
                                          base: InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >;
                                      },
                                  >;
                                  swim: SchemaField<
                                      {
                                          base: NumberField<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      { initial: undefined; required: boolean },
                                      AssignmentType<
                                          { base: NumberField<(...), (...), (...), (...)> },
                                          SimpleMerge<{ initial: ...; required: ... }, DefaultOptions>,
                                      >,
                                      {
                                          base: InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >;
                                      },
                                      {
                                          base: InitializedType<
                                              {
                                                  initial: ...;
                                                  integer: ...;
                                                  min: ...;
                                                  nullable: ...;
                                                  required: ...;
                                              },
                                          >;
                                      },
                                  >;
                              },
                              SimpleMerge<DefaultOptions, DefaultOptions>,
                          >,
                          {
                              burrow: {
                                  base: InitializedType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                  >;
                              };
                              climb: {
                                  base: InitializedType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                  >;
                              };
                              fly: {
                                  base: InitializedType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                  >;
                                  maneuverability: InitializedType<
                                      { choices: () => (...)[]; initial: undefined; required: boolean },
                                  >;
                              };
                              land: {
                                  base: InitializedType<
                                      {
                                          initial: 30;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                  >;
                              };
                              swim: {
                                  base: InitializedType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                  >;
                              };
                          },
                          {
                              burrow: {
                                  base: InitializedType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                  >;
                              };
                              climb: {
                                  base: InitializedType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                  >;
                              };
                              fly: {
                                  base: InitializedType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                  >;
                                  maneuverability: InitializedType<
                                      { choices: () => (...)[]; initial: undefined; required: boolean },
                                  >;
                              };
                              land: {
                                  base: InitializedType<
                                      {
                                          initial: 30;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                  >;
                              };
                              swim: {
                                  base: InitializedType<
                                      {
                                          initial: undefined;
                                          integer: true;
                                          min: 0;
                                          nullable: true;
                                          required: boolean;
                                      },
                                  >;
                              };
                          },
                      >;
                      sr: SchemaField<
                          { formula: FormulaField },
                          { initial: undefined; required: boolean },
                          AssignmentType<
                              { formula: FormulaField },
                              SimpleMerge<{ initial: undefined; required: boolean }, DefaultOptions>,
                          >,
                          { formula: InitializedType<DefaultOptions> },
                          { formula: InitializedType<DefaultOptions> },
                      >;
                      srNotes: StringField<
                          { blank: true; initial: undefined; required: boolean },
                          AssignmentType<{ blank: true; initial: undefined; required: boolean }>,
                          InitializedType<{ blank: true; initial: undefined; required: boolean }>,
                          InitializedType<{ blank: true; initial: undefined; required: boolean }>,
                      >;
                      vigor: SchemaField<
                          {
                              offset: NumberField<
                                  { initial: number; integer: boolean; nullable: boolean },
                                  AssignmentType<
                                      { initial: number; integer: boolean; nullable: boolean },
                                  >,
                                  InitializedType<
                                      { initial: number; integer: boolean; nullable: boolean },
                                  >,
                                  InitializedType<
                                      { initial: number; integer: boolean; nullable: boolean },
                                  >,
                              >;
                              temp: NumberField<
                                  { initial: number; integer: boolean; min: 0; nullable: boolean },
                                  AssignmentType<
                                      { initial: number; integer: boolean; min: 0; nullable: boolean },
                                  >,
                                  InitializedType<
                                      { initial: number; integer: boolean; min: 0; nullable: boolean },
                                  >,
                                  InitializedType<
                                      { initial: number; integer: boolean; min: 0; nullable: boolean },
                                  >,
                              >;
                          },
                          DefaultOptions,
                          AssignmentType<
                              {
                                  offset: NumberField<
                                      { initial: number; integer: boolean; nullable: boolean },
                                      AssignmentType<
                                          { initial: number; integer: boolean; nullable: boolean },
                                      >,
                                      InitializedType<
                                          { initial: number; integer: boolean; nullable: boolean },
                                      >,
                                      InitializedType<
                                          { initial: number; integer: boolean; nullable: boolean },
                                      >,
                                  >;
                                  temp: NumberField<
                                      { initial: number; integer: boolean; min: 0; nullable: boolean },
                                      AssignmentType<
                                          { initial: number; integer: boolean; min: 0; nullable: boolean },
                                      >,
                                      InitializedType<
                                          { initial: number; integer: boolean; min: 0; nullable: boolean },
                                      >,
                                      InitializedType<
                                          { initial: number; integer: boolean; min: 0; nullable: boolean },
                                      >,
                                  >;
                              },
                              SimpleMerge<DefaultOptions, DefaultOptions>,
                          >,
                          {
                              offset: InitializedType<
                                  { initial: number; integer: boolean; nullable: boolean },
                              >;
                              temp: InitializedType<
                                  { initial: number; integer: boolean; min: 0; nullable: boolean },
                              >;
                          },
                          {
                              offset: InitializedType<
                                  { initial: number; integer: boolean; nullable: boolean },
                              >;
                              temp: InitializedType<
                                  { initial: number; integer: boolean; min: 0; nullable: boolean },
                              >;
                          },
                      >;
                      wounds: SchemaField<
                          {
                              offset: NumberField<
                                  { initial: number; integer: boolean; nullable: boolean },
                                  AssignmentType<
                                      { initial: number; integer: boolean; nullable: boolean },
                                  >,
                                  InitializedType<
                                      { initial: number; integer: boolean; nullable: boolean },
                                  >,
                                  InitializedType<
                                      { initial: number; integer: boolean; nullable: boolean },
                                  >,
                              >;
                          },
                          DefaultOptions,
                          AssignmentType<
                              {
                                  offset: NumberField<
                                      { initial: number; integer: boolean; nullable: boolean },
                                      AssignmentType<
                                          { initial: number; integer: boolean; nullable: boolean },
                                      >,
                                      InitializedType<
                                          { initial: number; integer: boolean; nullable: boolean },
                                      >,
                                      InitializedType<
                                          { initial: number; integer: boolean; nullable: boolean },
                                      >,
                                  >;
                              },
                              SimpleMerge<DefaultOptions, DefaultOptions>,
                          >,
                          {
                              offset: InitializedType<
                                  { initial: number; integer: boolean; nullable: boolean },
                              >;
                          },
                          {
                              offset: InitializedType<
                                  { initial: number; integer: boolean; nullable: boolean },
                              >;
                          },
                      >;
                  },
                  SimpleMerge<DefaultOptions, DefaultOptions>,
              >,
              {
                  ac: {
                      normal: {
                          ability: InitializedType<
                              { blank: true; initial: undefined; required: boolean },
                          >;
                      };
                      touch: {
                          ability: InitializedType<
                              { blank: true; initial: undefined; required: boolean },
                          >;
                      };
                  };
                  acNotes: InitializedType<
                      { blank: true; initial: undefined; required: boolean },
                  >;
                  attack: {
                      meleeAbility: InitializedType<
                          { blank: true; initial: undefined; required: boolean },
                      >;
                      rangedAbility: InitializedType<
                          { blank: true; initial: undefined; required: boolean },
                      >;
                  };
                  cmbAbility: InitializedType<
                      { blank: true; initial: undefined; required: boolean },
                  >;
                  cmd: {
                      dexAbility: InitializedType<
                          { blank: true; initial: undefined; required: boolean },
                      >;
                      strAbility: InitializedType<
                          { blank: true; initial: undefined; required: boolean },
                      >;
                  };
                  cmdNotes: InitializedType<
                      { blank: true; initial: undefined; required: boolean },
                  >;
                  energyDrain: InitializedType<
                      {
                          initial: undefined;
                          integer: true;
                          min: 0;
                          nullable: true;
                          required: boolean;
                      },
                  >;
                  hp: {
                      nonlethal: InitializedType<
                          { initial: number; integer: boolean; min: 0; nullable: boolean },
                      >;
                      offset: InitializedType<
                          { initial: number; integer: boolean; nullable: boolean },
                      >;
                      temp: InitializedType<
                          { initial: number; integer: boolean; min: 0; nullable: boolean },
                      >;
                  };
                  hpAbility: InitializedType<
                      { blank: true; initial: undefined; required: boolean },
                  >;
                  init: {
                      ability: InitializedType<
                          { blank: true; initial: undefined; required: boolean },
                      >;
                      value: InitializedType<
                          { initial: undefined; integer: true; required: boolean },
                      >;
                  };
                  naturalAC: InitializedType<
                      {
                          initial: undefined;
                          integer: boolean;
                          min: 0;
                          nullable: true;
                          required: boolean;
                      },
                  >;
                  quadruped: InitializedType<
                      SimpleMerge<
                          { initial: undefined; nullable: true; required: boolean },
                          DefaultOptions,
                      >,
                  >;
                  saveNotes: InitializedType<
                      { blank: true; initial: undefined; required: boolean },
                  >;
                  savingThrows: {
                      [key: string]: {
                          ability: InitializedType<
                              { blank: true; initial: undefined; required: boolean },
                          >;
                          base: InitializedType<
                              { initial: undefined; integer: true; required: boolean },
                          >;
                      };
                  };
                  speed: {
                      burrow: {
                          base: InitializedType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: boolean;
                              },
                          >;
                      };
                      climb: {
                          base: InitializedType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: boolean;
                              },
                          >;
                      };
                      fly: {
                          base: InitializedType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: boolean;
                              },
                          >;
                          maneuverability: InitializedType<
                              { choices: () => string[]; initial: undefined; required: boolean },
                          >;
                      };
                      land: {
                          base: InitializedType<
                              {
                                  initial: 30;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: boolean;
                              },
                          >;
                      };
                      swim: {
                          base: InitializedType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: boolean;
                              },
                          >;
                      };
                  };
                  sr: { formula: InitializedType<DefaultOptions> };
                  srNotes: InitializedType<
                      { blank: true; initial: undefined; required: boolean },
                  >;
                  vigor: {
                      offset: InitializedType<
                          { initial: number; integer: boolean; nullable: boolean },
                      >;
                      temp: InitializedType<
                          { initial: number; integer: boolean; min: 0; nullable: boolean },
                      >;
                  };
                  wounds: {
                      offset: InitializedType<
                          { initial: number; integer: boolean; nullable: boolean },
                      >;
                  };
              },
              {
                  ac: {
                      normal: {
                          ability: InitializedType<
                              { blank: true; initial: undefined; required: boolean },
                          >;
                      };
                      touch: {
                          ability: InitializedType<
                              { blank: true; initial: undefined; required: boolean },
                          >;
                      };
                  };
                  acNotes: InitializedType<
                      { blank: true; initial: undefined; required: boolean },
                  >;
                  attack: {
                      meleeAbility: InitializedType<
                          { blank: true; initial: undefined; required: boolean },
                      >;
                      rangedAbility: InitializedType<
                          { blank: true; initial: undefined; required: boolean },
                      >;
                  };
                  cmbAbility: InitializedType<
                      { blank: true; initial: undefined; required: boolean },
                  >;
                  cmd: {
                      dexAbility: InitializedType<
                          { blank: true; initial: undefined; required: boolean },
                      >;
                      strAbility: InitializedType<
                          { blank: true; initial: undefined; required: boolean },
                      >;
                  };
                  cmdNotes: InitializedType<
                      { blank: true; initial: undefined; required: boolean },
                  >;
                  energyDrain: InitializedType<
                      {
                          initial: undefined;
                          integer: true;
                          min: 0;
                          nullable: true;
                          required: boolean;
                      },
                  >;
                  hp: {
                      nonlethal: InitializedType<
                          { initial: number; integer: boolean; min: 0; nullable: boolean },
                      >;
                      offset: InitializedType<
                          { initial: number; integer: boolean; nullable: boolean },
                      >;
                      temp: InitializedType<
                          { initial: number; integer: boolean; min: 0; nullable: boolean },
                      >;
                  };
                  hpAbility: InitializedType<
                      { blank: true; initial: undefined; required: boolean },
                  >;
                  init: {
                      ability: InitializedType<
                          { blank: true; initial: undefined; required: boolean },
                      >;
                      value: InitializedType<
                          { initial: undefined; integer: true; required: boolean },
                      >;
                  };
                  naturalAC: InitializedType<
                      {
                          initial: undefined;
                          integer: boolean;
                          min: 0;
                          nullable: true;
                          required: boolean;
                      },
                  >;
                  quadruped: InitializedType<
                      SimpleMerge<
                          { initial: undefined; nullable: true; required: boolean },
                          DefaultOptions,
                      >,
                  >;
                  saveNotes: InitializedType<
                      { blank: true; initial: undefined; required: boolean },
                  >;
                  savingThrows: {
                      [key: string]: {
                          ability: InitializedType<
                              { blank: true; initial: undefined; required: boolean },
                          >;
                          base: InitializedType<
                              { initial: undefined; integer: true; required: boolean },
                          >;
                      };
                  };
                  speed: {
                      burrow: {
                          base: InitializedType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: boolean;
                              },
                          >;
                      };
                      climb: {
                          base: InitializedType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: boolean;
                              },
                          >;
                      };
                      fly: {
                          base: InitializedType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: boolean;
                              },
                          >;
                          maneuverability: InitializedType<
                              { choices: () => string[]; initial: undefined; required: boolean },
                          >;
                      };
                      land: {
                          base: InitializedType<
                              {
                                  initial: 30;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: boolean;
                              },
                          >;
                      };
                      swim: {
                          base: InitializedType<
                              {
                                  initial: undefined;
                                  integer: true;
                                  min: 0;
                                  nullable: true;
                                  required: boolean;
                              },
                          >;
                      };
                  };
                  sr: { formula: InitializedType<DefaultOptions> };
                  srNotes: InitializedType<
                      { blank: true; initial: undefined; required: boolean },
                  >;
                  vigor: {
                      offset: InitializedType<
                          { initial: number; integer: boolean; nullable: boolean },
                      >;
                      temp: InitializedType<
                          { initial: number; integer: boolean; min: 0; nullable: boolean },
                      >;
                  };
                  wounds: {
                      offset: InitializedType<
                          { initial: number; integer: boolean; nullable: boolean },
                      >;
                  };
              },
          >;
          config: SchemaField<
              {
                  noManeuvers: BooleanField<
                      { initial: undefined; required: boolean },
                      AssignmentType<
                          SimpleMerge<
                              { initial: undefined; required: boolean },
                              DefaultOptions,
                          >,
                      >,
                      InitializedType<
                          SimpleMerge<
                              { initial: undefined; required: boolean },
                              DefaultOptions,
                          >,
                      >,
                      InitializedType<
                          SimpleMerge<
                              { initial: undefined; required: boolean },
                              DefaultOptions,
                          >,
                      >,
                  >;
              },
              { initial: undefined; required: boolean },
              AssignmentType<
                  {
                      noManeuvers: BooleanField<
                          { initial: undefined; required: boolean },
                          AssignmentType<
                              SimpleMerge<
                                  { initial: undefined; required: boolean },
                                  DefaultOptions,
                              >,
                          >,
                          InitializedType<
                              SimpleMerge<
                                  { initial: undefined; required: boolean },
                                  DefaultOptions,
                              >,
                          >,
                          InitializedType<
                              SimpleMerge<
                                  { initial: undefined; required: boolean },
                                  DefaultOptions,
                              >,
                          >,
                      >;
                  },
                  SimpleMerge<{ initial: undefined; required: boolean }, DefaultOptions>,
              >,
              {
                  noManeuvers: InitializedType<
                      SimpleMerge<
                          { initial: undefined; required: boolean },
                          DefaultOptions,
                      >,
                  >;
              },
              {
                  noManeuvers: InitializedType<
                      SimpleMerge<
                          { initial: undefined; required: boolean },
                          DefaultOptions,
                      >,
                  >;
              },
          >;
          currency: TypedObjectField<
              NumberField<
                  { integer: true; min: 0 },
                  AssignmentType<{ integer: true; min: 0 }>,
                  InitializedType<{ integer: true; min: 0 }>,
                  InitializedType<{ integer: true; min: 0 }>,
              >,
              DefaultOptions,
              AssignmentType<
                  NumberField<
                      { integer: true; min: 0 },
                      AssignmentType<{ integer: true; min: 0 }>,
                      InitializedType<{ integer: true; min: 0 }>,
                      InitializedType<{ integer: true; min: 0 }>,
                  >,
                  DefaultOptions,
              >,
              { [key: string]: InitializedType<{ integer: true; min: 0 }> },
              { [key: string]: InitializedType<{ integer: true; min: 0 }> },
          >;
          details: SchemaField<
              {
                  age: StringField<
                      { initial: undefined; required: boolean },
                      AssignmentType<{ initial: undefined; required: boolean }>,
                      InitializedType<{ initial: undefined; required: boolean }>,
                      InitializedType<{ initial: undefined; required: boolean }>,
                  >;
                  alignment: StringField<
                      { initial: "tn"; required: boolean },
                      AssignmentType<{ initial: "tn"; required: boolean }>,
                      InitializedType<{ initial: "tn"; required: boolean }>,
                      InitializedType<{ initial: "tn"; required: boolean }>,
                  >;
                  biography: SchemaField<
                      {
                          value: HTMLField<
                              { initial: undefined; required: boolean },
                              AssignmentType<{ initial: undefined; required: boolean }>,
                              InitializedType<{ initial: undefined; required: boolean }>,
                              InitializedType<{ initial: undefined; required: boolean }>,
                          >;
                      },
                      DefaultOptions,
                      AssignmentType<
                          {
                              value: HTMLField<
                                  { initial: undefined; required: boolean },
                                  AssignmentType<{ initial: undefined; required: boolean }>,
                                  InitializedType<{ initial: undefined; required: boolean }>,
                                  InitializedType<{ initial: undefined; required: boolean }>,
                              >;
                          },
                          SimpleMerge<DefaultOptions, DefaultOptions>,
                      >,
                      { value: InitializedType<{ initial: undefined; required: boolean }> },
                      { value: InitializedType<{ initial: undefined; required: boolean }> },
                  >;
                  bonusFeatFormula: FormulaField;
                  bonusSkillRankFormula: FormulaField;
                  carryCapacity: SchemaField<
                      {
                          bonus: SchemaField<
                              {
                                  user: NumberField<
                                      { initial: undefined; integer: true; required: boolean },
                                      AssignmentType<
                                          { initial: undefined; integer: true; required: boolean },
                                      >,
                                      InitializedType<
                                          { initial: undefined; integer: true; required: boolean },
                                      >,
                                      InitializedType<
                                          { initial: undefined; integer: true; required: boolean },
                                      >,
                                  >;
                              },
                              { initial: undefined; required: boolean },
                              AssignmentType<
                                  {
                                      user: NumberField<
                                          { initial: undefined; integer: true; required: boolean },
                                          AssignmentType<{ initial: ...; integer: ...; required: ... }>,
                                          InitializedType<{ initial: ...; integer: ...; required: ... }>,
                                          InitializedType<{ initial: ...; integer: ...; required: ... }>,
                                      >;
                                  },
                                  SimpleMerge<
                                      { initial: undefined; required: boolean },
                                      DefaultOptions,
                                  >,
                              >,
                              {
                                  user: InitializedType<
                                      { initial: undefined; integer: true; required: boolean },
                                  >;
                              },
                              {
                                  user: InitializedType<
                                      { initial: undefined; integer: true; required: boolean },
                                  >;
                              },
                          >;
                          multiplier: SchemaField<
                              {
                                  base: NumberField<
                                      { initial: 1; integer: true; min: 1; required: boolean },
                                      AssignmentType<
                                          { initial: 1; integer: true; min: 1; required: boolean },
                                      >,
                                      InitializedType<
                                          { initial: 1; integer: true; min: 1; required: boolean },
                                      >,
                                      InitializedType<
                                          { initial: 1; integer: true; min: 1; required: boolean },
                                      >,
                                  >;
                                  user: NumberField<
                                      { initial: 0; integer: true; min: 0; required: boolean },
                                      AssignmentType<
                                          { initial: 0; integer: true; min: 0; required: boolean },
                                      >,
                                      InitializedType<
                                          { initial: 0; integer: true; min: 0; required: boolean },
                                      >,
                                      InitializedType<
                                          { initial: 0; integer: true; min: 0; required: boolean },
                                      >,
                                  >;
                              },
                              { initial: undefined; required: boolean },
                              AssignmentType<
                                  {
                                      base: NumberField<
                                          { initial: 1; integer: true; min: 1; required: boolean },
                                          AssignmentType<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                          >,
                                          InitializedType<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                          >,
                                          InitializedType<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                          >,
                                      >;
                                      user: NumberField<
                                          { initial: 0; integer: true; min: 0; required: boolean },
                                          AssignmentType<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                          >,
                                          InitializedType<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                          >,
                                          InitializedType<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                          >,
                                      >;
                                  },
                                  SimpleMerge<
                                      { initial: undefined; required: boolean },
                                      DefaultOptions,
                                  >,
                              >,
                              {
                                  base: InitializedType<
                                      { initial: 1; integer: true; min: 1; required: boolean },
                                  >;
                                  user: InitializedType<
                                      { initial: 0; integer: true; min: 0; required: boolean },
                                  >;
                              },
                              {
                                  base: InitializedType<
                                      { initial: 1; integer: true; min: 1; required: boolean },
                                  >;
                                  user: InitializedType<
                                      { initial: 0; integer: true; min: 0; required: boolean },
                                  >;
                              },
                          >;
                      },
                      { initial: undefined; required: boolean },
                      AssignmentType<
                          {
                              bonus: SchemaField<
                                  {
                                      user: NumberField<
                                          { initial: undefined; integer: true; required: boolean },
                                          AssignmentType<{ initial: ...; integer: ...; required: ... }>,
                                          InitializedType<{ initial: ...; integer: ...; required: ... }>,
                                          InitializedType<{ initial: ...; integer: ...; required: ... }>,
                                      >;
                                  },
                                  { initial: undefined; required: boolean },
                                  AssignmentType<
                                      {
                                          user: NumberField<
                                              { initial: ...; integer: ...; required: ... },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      SimpleMerge<
                                          { initial: undefined; required: boolean },
                                          DefaultOptions,
                                      >,
                                  >,
                                  {
                                      user: InitializedType<
                                          { initial: undefined; integer: true; required: boolean },
                                      >;
                                  },
                                  {
                                      user: InitializedType<
                                          { initial: undefined; integer: true; required: boolean },
                                      >;
                                  },
                              >;
                              multiplier: SchemaField<
                                  {
                                      base: NumberField<
                                          { initial: 1; integer: true; min: 1; required: boolean },
                                          AssignmentType<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                          >,
                                          InitializedType<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                          >,
                                          InitializedType<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                          >,
                                      >;
                                      user: NumberField<
                                          { initial: 0; integer: true; min: 0; required: boolean },
                                          AssignmentType<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                          >,
                                          InitializedType<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                          >,
                                          InitializedType<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                          >,
                                      >;
                                  },
                                  { initial: undefined; required: boolean },
                                  AssignmentType<
                                      {
                                          base: NumberField<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                          user: NumberField<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      SimpleMerge<
                                          { initial: undefined; required: boolean },
                                          DefaultOptions,
                                      >,
                                  >,
                                  {
                                      base: InitializedType<
                                          { initial: 1; integer: true; min: 1; required: boolean },
                                      >;
                                      user: InitializedType<
                                          { initial: 0; integer: true; min: 0; required: boolean },
                                      >;
                                  },
                                  {
                                      base: InitializedType<
                                          { initial: 1; integer: true; min: 1; required: boolean },
                                      >;
                                      user: InitializedType<
                                          { initial: 0; integer: true; min: 0; required: boolean },
                                      >;
                                  },
                              >;
                          },
                          SimpleMerge<{ initial: undefined; required: boolean }, DefaultOptions>,
                      >,
                      {
                          bonus: {
                              user: InitializedType<
                                  { initial: undefined; integer: true; required: boolean },
                              >;
                          };
                          multiplier: {
                              base: InitializedType<
                                  { initial: 1; integer: true; min: 1; required: boolean },
                              >;
                              user: InitializedType<
                                  { initial: 0; integer: true; min: 0; required: boolean },
                              >;
                          };
                      },
                      {
                          bonus: {
                              user: InitializedType<
                                  { initial: undefined; integer: true; required: boolean },
                              >;
                          };
                          multiplier: {
                              base: InitializedType<
                                  { initial: 1; integer: true; min: 1; required: boolean },
                              >;
                              user: InitializedType<
                                  { initial: 0; integer: true; min: 0; required: boolean },
                              >;
                          };
                      },
                  >;
                  deity: StringField<
                      { initial: undefined; required: boolean },
                      AssignmentType<{ initial: undefined; required: boolean }>,
                      InitializedType<{ initial: undefined; required: boolean }>,
                      InitializedType<{ initial: undefined; required: boolean }>,
                  >;
                  gender: StringField<
                      { initial: undefined; required: boolean },
                      AssignmentType<{ initial: undefined; required: boolean }>,
                      InitializedType<{ initial: undefined; required: boolean }>,
                      InitializedType<{ initial: undefined; required: boolean }>,
                  >;
                  height: StringField<
                      { initial: undefined; required: boolean },
                      AssignmentType<{ initial: undefined; required: boolean }>,
                      InitializedType<{ initial: undefined; required: boolean }>,
                      InitializedType<{ initial: undefined; required: boolean }>,
                  >;
                  notes: SchemaField<
                      {
                          value: HTMLField<
                              { initial: undefined; required: boolean },
                              AssignmentType<{ initial: undefined; required: boolean }>,
                              InitializedType<{ initial: undefined; required: boolean }>,
                              InitializedType<{ initial: undefined; required: boolean }>,
                          >;
                      },
                      DefaultOptions,
                      AssignmentType<
                          {
                              value: HTMLField<
                                  { initial: undefined; required: boolean },
                                  AssignmentType<{ initial: undefined; required: boolean }>,
                                  InitializedType<{ initial: undefined; required: boolean }>,
                                  InitializedType<{ initial: undefined; required: boolean }>,
                              >;
                          },
                          SimpleMerge<DefaultOptions, DefaultOptions>,
                      >,
                      { value: InitializedType<{ initial: undefined; required: boolean }> },
                      { value: InitializedType<{ initial: undefined; required: boolean }> },
                  >;
                  weight: StringField<
                      { initial: undefined; required: boolean },
                      AssignmentType<{ initial: undefined; required: boolean }>,
                      InitializedType<{ initial: undefined; required: boolean }>,
                      InitializedType<{ initial: undefined; required: boolean }>,
                  >;
                  xp: SchemaField<
                      {
                          value: NumberField<
                              { initial: 0; integer: true; min: 0 },
                              AssignmentType<{ initial: 0; integer: true; min: 0 }>,
                              InitializedType<{ initial: 0; integer: true; min: 0 }>,
                              InitializedType<{ initial: 0; integer: true; min: 0 }>,
                          >;
                      },
                      DefaultOptions,
                      AssignmentType<
                          {
                              value: NumberField<
                                  { initial: 0; integer: true; min: 0 },
                                  AssignmentType<{ initial: 0; integer: true; min: 0 }>,
                                  InitializedType<{ initial: 0; integer: true; min: 0 }>,
                                  InitializedType<{ initial: 0; integer: true; min: 0 }>,
                              >;
                          },
                          SimpleMerge<DefaultOptions, DefaultOptions>,
                      >,
                      { value: InitializedType<{ initial: 0; integer: true; min: 0 }> },
                      { value: InitializedType<{ initial: 0; integer: true; min: 0 }> },
                  >;
              },
              DefaultOptions,
              AssignmentType<
                  {
                      age: StringField<
                          { initial: undefined; required: boolean },
                          AssignmentType<{ initial: undefined; required: boolean }>,
                          InitializedType<{ initial: undefined; required: boolean }>,
                          InitializedType<{ initial: undefined; required: boolean }>,
                      >;
                      alignment: StringField<
                          { initial: "tn"; required: boolean },
                          AssignmentType<{ initial: "tn"; required: boolean }>,
                          InitializedType<{ initial: "tn"; required: boolean }>,
                          InitializedType<{ initial: "tn"; required: boolean }>,
                      >;
                      biography: SchemaField<
                          {
                              value: HTMLField<
                                  { initial: undefined; required: boolean },
                                  AssignmentType<{ initial: undefined; required: boolean }>,
                                  InitializedType<{ initial: undefined; required: boolean }>,
                                  InitializedType<{ initial: undefined; required: boolean }>,
                              >;
                          },
                          DefaultOptions,
                          AssignmentType<
                              {
                                  value: HTMLField<
                                      { initial: undefined; required: boolean },
                                      AssignmentType<{ initial: undefined; required: boolean }>,
                                      InitializedType<{ initial: undefined; required: boolean }>,
                                      InitializedType<{ initial: undefined; required: boolean }>,
                                  >;
                              },
                              SimpleMerge<DefaultOptions, DefaultOptions>,
                          >,
                          { value: InitializedType<{ initial: undefined; required: boolean }> },
                          { value: InitializedType<{ initial: undefined; required: boolean }> },
                      >;
                      bonusFeatFormula: FormulaField;
                      bonusSkillRankFormula: FormulaField;
                      carryCapacity: SchemaField<
                          {
                              bonus: SchemaField<
                                  {
                                      user: NumberField<
                                          { initial: undefined; integer: true; required: boolean },
                                          AssignmentType<{ initial: ...; integer: ...; required: ... }>,
                                          InitializedType<{ initial: ...; integer: ...; required: ... }>,
                                          InitializedType<{ initial: ...; integer: ...; required: ... }>,
                                      >;
                                  },
                                  { initial: undefined; required: boolean },
                                  AssignmentType<
                                      {
                                          user: NumberField<
                                              { initial: ...; integer: ...; required: ... },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      SimpleMerge<
                                          { initial: undefined; required: boolean },
                                          DefaultOptions,
                                      >,
                                  >,
                                  {
                                      user: InitializedType<
                                          { initial: undefined; integer: true; required: boolean },
                                      >;
                                  },
                                  {
                                      user: InitializedType<
                                          { initial: undefined; integer: true; required: boolean },
                                      >;
                                  },
                              >;
                              multiplier: SchemaField<
                                  {
                                      base: NumberField<
                                          { initial: 1; integer: true; min: 1; required: boolean },
                                          AssignmentType<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                          >,
                                          InitializedType<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                          >,
                                          InitializedType<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                          >,
                                      >;
                                      user: NumberField<
                                          { initial: 0; integer: true; min: 0; required: boolean },
                                          AssignmentType<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                          >,
                                          InitializedType<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                          >,
                                          InitializedType<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                          >,
                                      >;
                                  },
                                  { initial: undefined; required: boolean },
                                  AssignmentType<
                                      {
                                          base: NumberField<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                          user: NumberField<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      SimpleMerge<
                                          { initial: undefined; required: boolean },
                                          DefaultOptions,
                                      >,
                                  >,
                                  {
                                      base: InitializedType<
                                          { initial: 1; integer: true; min: 1; required: boolean },
                                      >;
                                      user: InitializedType<
                                          { initial: 0; integer: true; min: 0; required: boolean },
                                      >;
                                  },
                                  {
                                      base: InitializedType<
                                          { initial: 1; integer: true; min: 1; required: boolean },
                                      >;
                                      user: InitializedType<
                                          { initial: 0; integer: true; min: 0; required: boolean },
                                      >;
                                  },
                              >;
                          },
                          { initial: undefined; required: boolean },
                          AssignmentType<
                              {
                                  bonus: SchemaField<
                                      {
                                          user: NumberField<
                                              { initial: ...; integer: ...; required: ... },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      { initial: undefined; required: boolean },
                                      AssignmentType<
                                          { user: NumberField<(...), (...), (...), (...)> },
                                          SimpleMerge<{ initial: ...; required: ... }, DefaultOptions>,
                                      >,
                                      {
                                          user: InitializedType<
                                              { initial: ...; integer: ...; required: ... },
                                          >;
                                      },
                                      {
                                          user: InitializedType<
                                              { initial: ...; integer: ...; required: ... },
                                          >;
                                      },
                                  >;
                                  multiplier: SchemaField<
                                      {
                                          base: NumberField<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                          user: NumberField<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                              AssignmentType<(...)>,
                                              InitializedType<(...)>,
                                              InitializedType<(...)>,
                                          >;
                                      },
                                      { initial: undefined; required: boolean },
                                      AssignmentType<
                                          {
                                              base: NumberField<(...), (...), (...), (...)>;
                                              user: NumberField<(...), (...), (...), (...)>;
                                          },
                                          SimpleMerge<{ initial: ...; required: ... }, DefaultOptions>,
                                      >,
                                      {
                                          base: InitializedType<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                          >;
                                          user: InitializedType<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                          >;
                                      },
                                      {
                                          base: InitializedType<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                          >;
                                          user: InitializedType<
                                              { initial: ...; integer: ...; min: ...; required: ... },
                                          >;
                                      },
                                  >;
                              },
                              SimpleMerge<{ initial: undefined; required: boolean }, DefaultOptions>,
                          >,
                          {
                              bonus: {
                                  user: InitializedType<
                                      { initial: undefined; integer: true; required: boolean },
                                  >;
                              };
                              multiplier: {
                                  base: InitializedType<
                                      { initial: 1; integer: true; min: 1; required: boolean },
                                  >;
                                  user: InitializedType<
                                      { initial: 0; integer: true; min: 0; required: boolean },
                                  >;
                              };
                          },
                          {
                              bonus: {
                                  user: InitializedType<
                                      { initial: undefined; integer: true; required: boolean },
                                  >;
                              };
                              multiplier: {
                                  base: InitializedType<
                                      { initial: 1; integer: true; min: 1; required: boolean },
                                  >;
                                  user: InitializedType<
                                      { initial: 0; integer: true; min: 0; required: boolean },
                                  >;
                              };
                          },
                      >;
                      deity: StringField<
                          { initial: undefined; required: boolean },
                          AssignmentType<{ initial: undefined; required: boolean }>,
                          InitializedType<{ initial: undefined; required: boolean }>,
                          InitializedType<{ initial: undefined; required: boolean }>,
                      >;
                      gender: StringField<
                          { initial: undefined; required: boolean },
                          AssignmentType<{ initial: undefined; required: boolean }>,
                          InitializedType<{ initial: undefined; required: boolean }>,
                          InitializedType<{ initial: undefined; required: boolean }>,
                      >;
                      height: StringField<
                          { initial: undefined; required: boolean },
                          AssignmentType<{ initial: undefined; required: boolean }>,
                          InitializedType<{ initial: undefined; required: boolean }>,
                          InitializedType<{ initial: undefined; required: boolean }>,
                      >;
                      notes: SchemaField<
                          {
                              value: HTMLField<
                                  { initial: undefined; required: boolean },
                                  AssignmentType<{ initial: undefined; required: boolean }>,
                                  InitializedType<{ initial: undefined; required: boolean }>,
                                  InitializedType<{ initial: undefined; required: boolean }>,
                              >;
                          },
                          DefaultOptions,
                          AssignmentType<
                              {
                                  value: HTMLField<
                                      { initial: undefined; required: boolean },
                                      AssignmentType<{ initial: undefined; required: boolean }>,
                                      InitializedType<{ initial: undefined; required: boolean }>,
                                      InitializedType<{ initial: undefined; required: boolean }>,
                                  >;
                              },
                              SimpleMerge<DefaultOptions, DefaultOptions>,
                          >,
                          { value: InitializedType<{ initial: undefined; required: boolean }> },
                          { value: InitializedType<{ initial: undefined; required: boolean }> },
                      >;
                      weight: StringField<
                          { initial: undefined; required: boolean },
                          AssignmentType<{ initial: undefined; required: boolean }>,
                          InitializedType<{ initial: undefined; required: boolean }>,
                          InitializedType<{ initial: undefined; required: boolean }>,
                      >;
                      xp: SchemaField<
                          {
                              value: NumberField<
                                  { initial: 0; integer: true; min: 0 },
                                  AssignmentType<{ initial: 0; integer: true; min: 0 }>,
                                  InitializedType<{ initial: 0; integer: true; min: 0 }>,
                                  InitializedType<{ initial: 0; integer: true; min: 0 }>,
                              >;
                          },
                          DefaultOptions,
                          AssignmentType<
                              {
                                  value: NumberField<
                                      { initial: 0; integer: true; min: 0 },
                                      AssignmentType<{ initial: 0; integer: true; min: 0 }>,
                                      InitializedType<{ initial: 0; integer: true; min: 0 }>,
                                      InitializedType<{ initial: 0; integer: true; min: 0 }>,
                                  >;
                              },
                              SimpleMerge<DefaultOptions, DefaultOptions>,
                          >,
                          { value: InitializedType<{ initial: 0; integer: true; min: 0 }> },
                          { value: InitializedType<{ initial: 0; integer: true; min: 0 }> },
                      >;
                  },
                  SimpleMerge<DefaultOptions, DefaultOptions>,
              >,
              {
                  age: InitializedType<{ initial: undefined; required: boolean }>;
                  alignment: InitializedType<{ initial: "tn"; required: boolean }>;
                  biography: {
                      value: InitializedType<{ initial: undefined; required: boolean }>;
                  };
                  bonusFeatFormula: InitializedType<DefaultOptions>;
                  bonusSkillRankFormula: InitializedType<DefaultOptions>;
                  carryCapacity: {
                      bonus: {
                          user: InitializedType<
                              { initial: undefined; integer: true; required: boolean },
                          >;
                      };
                      multiplier: {
                          base: InitializedType<
                              { initial: 1; integer: true; min: 1; required: boolean },
                          >;
                          user: InitializedType<
                              { initial: 0; integer: true; min: 0; required: boolean },
                          >;
                      };
                  };
                  deity: InitializedType<{ initial: undefined; required: boolean }>;
                  gender: InitializedType<{ initial: undefined; required: boolean }>;
                  height: InitializedType<{ initial: undefined; required: boolean }>;
                  notes: {
                      value: InitializedType<{ initial: undefined; required: boolean }>;
                  };
                  weight: InitializedType<{ initial: undefined; required: boolean }>;
                  xp: { value: InitializedType<{ initial: 0; integer: true; min: 0 }> };
              },
              {
                  age: InitializedType<{ initial: undefined; required: boolean }>;
                  alignment: InitializedType<{ initial: "tn"; required: boolean }>;
                  biography: {
                      value: InitializedType<{ initial: undefined; required: boolean }>;
                  };
                  bonusFeatFormula: InitializedType<DefaultOptions>;
                  bonusSkillRankFormula: InitializedType<DefaultOptions>;
                  carryCapacity: {
                      bonus: {
                          user: InitializedType<
                              { initial: undefined; integer: true; required: boolean },
                          >;
                      };
                      multiplier: {
                          base: InitializedType<
                              { initial: 1; integer: true; min: 1; required: boolean },
                          >;
                          user: InitializedType<
                              { initial: 0; integer: true; min: 0; required: boolean },
                          >;
                      };
                  };
                  deity: InitializedType<{ initial: undefined; required: boolean }>;
                  gender: InitializedType<{ initial: undefined; required: boolean }>;
                  height: InitializedType<{ initial: undefined; required: boolean }>;
                  notes: {
                      value: InitializedType<{ initial: undefined; required: boolean }>;
                  };
                  weight: InitializedType<{ initial: undefined; required: boolean }>;
                  xp: { value: InitializedType<{ initial: 0; integer: true; min: 0 }> };
              },
          >;
          skills: TypedObjectField<
              EmbeddedDataField<
                  typeof SkillModel,
                  DefaultOptions,
                  AssignmentType<typeof SkillModel, DefaultOptions>,
                  SkillModel,
                  {
                      ability: InitializedType<
                          { blank: true; initial: undefined; required: boolean },
                      >;
                      acp: InitializedType<
                          SimpleMerge<
                              { initial: undefined; required: boolean },
                              DefaultOptions,
                          >,
                      >;
                      journal: InitializedType<{ initial: undefined; required: boolean }>;
                      name: InitializedType<{ initial: undefined; required: boolean }>;
                      rank: InitializedType<
                          { initial: 0; integer: true; min: 0; required: false },
                      >;
                      rt: InitializedType<
                          SimpleMerge<
                              { initial: undefined; required: boolean },
                              DefaultOptions,
                          >,
                      >;
                      subSkills: { [key: string]: SkillData };
                  },
              >,
              DefaultOptions,
              AssignmentType<
                  EmbeddedDataField<
                      typeof SkillModel,
                      DefaultOptions,
                      AssignmentType<typeof SkillModel, DefaultOptions>,
                      SkillModel,
                      {
                          ability: InitializedType<
                              { blank: true; initial: undefined; required: boolean },
                          >;
                          acp: InitializedType<
                              SimpleMerge<
                                  { initial: undefined; required: boolean },
                                  DefaultOptions,
                              >,
                          >;
                          journal: InitializedType<{ initial: undefined; required: boolean }>;
                          name: InitializedType<{ initial: undefined; required: boolean }>;
                          rank: InitializedType<
                              { initial: 0; integer: true; min: 0; required: false },
                          >;
                          rt: InitializedType<
                              SimpleMerge<
                                  { initial: undefined; required: boolean },
                                  DefaultOptions,
                              >,
                          >;
                          subSkills: { [key: string]: SkillData };
                      },
                  >,
                  DefaultOptions,
              >,
              { [key: string]: SkillModel },
              { [key: string]: SkillModel },
          >;
          spells: TypedObjectField<
              EmbeddedDataField<
                  AnyConstructor,
                  DefaultOptions,
                  AssignmentType<AnyConstructor, DefaultOptions>,
                  AnyDataModel,
                  {},
              >,
              DefaultOptions,
              AssignmentType<
                  EmbeddedDataField<
                      AnyConstructor,
                      DefaultOptions,
                      AssignmentType<AnyConstructor, DefaultOptions>,
                      AnyDataModel,
                      {},
                  >,
                  DefaultOptions,
              >,
              { [key: string]: AnyDataModel },
              { [key: string]: AnyDataModel },
          >;
          traits: SchemaField<
              DataSchema,
              DefaultOptions,
              AssignmentType<DataSchema, SimpleMerge<DefaultOptions, DefaultOptions>>,
              {},
              {},
          >;
      }

    • Parameters

      • source: any

      Returns any

    • Parameters

      • source: any

      Returns void

    Settings

    Member Visibility

    On This Page

    Constructors
    Properties
    Accessors
    Methods