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

    Class ClassModel

    Base Item Model

    Datamodel expressing common elements to all items.

    Hierarchy (View Summary)

    Index

    Constructors

    constructor

    Properties

    alignment armorProf? bab babBase babFormula changeFlags? changes? classSkills? contextNotes? customHD description? fc flags? hd hitDice hp languages? level links mythicTier parent? savingThrows scriptCalls? skillsPerLevel subType? tag? wealth weaponProf? metadata

    Accessors

    activeState autoDeductCharges canUse charges hasFiniteCharges isActive isCharged isSingleUse maxCharges

    Methods

    _activeStateChange _chargePreUpdate _onCreate _onLevelChange _onUpdate _preCreate _prepareTraits _preUpdate _rechargeActions _rechargeUses _registerOnActor _updateChargeLinking _updateInheritedCharges getDefaultChargeCost getDefaultChargeFormula getLabels getName getRollData prepareBaseData prepareDependentData prepareDerivedData recharge setActive _adjustNewItem defineSchema migrateData migrateParentData pruneData

    Constructors

    Properties

    alignment: string
    armorProf?: Set<string>
    bab: string
    babBase: undefined | number
    babFormula: string
    changeFlags?: Set<string>
    changes?: ItemChange[]
    classSkills?: Set<string>
    contextNotes?: ContextNote[]
    customHD: string
    description?: { instructions?: string; summary?: string; value?: string }
    fc: {
        alt: { notes: string; value: number };
        hp: { value: number };
        skill: { value: number };
    }
    flags?: { boolean?: {}; dictionary?: {} }
    hd: number
    hitDice: undefined | number
    hp: number
    languages?: Set<string>
    level: number
    links: {
        children: LinkModel[];
        classAssociations: LinkModel[];
        supplements: LinkModel[];
    }
    mythicTier: undefined | number
    parent?: ItemPF
    savingThrows: {
        fort: { custom: string; value: string };
        ref: { custom: string; value: string };
        will: { custom: string; value: string };
    }
    scriptCalls?: ItemScriptCall[]
    skillsPerLevel: number
    subType?: string
    tag?: string
    wealth: string
    weaponProf?: Set<string>
    metadata: Readonly<
        {
            isPhysical: false;
            label: "CONFIG.Item.typeLabels.class";
            type: "class";
        },
    > = ...

    Accessors

    • get activeState(): boolean

      Active state as per what setActive would correspond with.

      Returns boolean

    • get autoDeductCharges(): boolean

      Consumes are adds charges by default.

      Returns boolean

    • get canUse(): boolean

      Is this item usable at base level, disregarding per-action details.

      Returns boolean

    • get charges(): number

      Remaining charges

      Returns number

    • get hasFiniteCharges(): boolean

      Finite charges

      Returns boolean

    • get isActive(): boolean

      Is Active

      This returns composite result of if the item is equipped, has quantity, is not disabled, is not out of charges, etc. and is not representative if the item can be set active or not via setActive.

      Returns boolean

      activeState

    • get isCharged(): boolean

      Returns boolean

    • get isSingleUse(): boolean

      Returns boolean

    • get maxCharges(): number

      Maximum possible charges this item can have.

      Returns number

      • Can return zero. Usually signifying something has reduced the potential uses below usability.
      • Can return infinity, signifying lack of limits.

    Methods

    Abstract_activeStateChange

    • _activeStateChange(changed: object): boolean
      Internal Experimental

      Return active state change from data if present

      This is a hack to allow item-type agnostic active state change detection.

      Parameters

      • changed: object

      Returns boolean

    _chargePreUpdate

    • _chargePreUpdate(changed: object, context: object): Promise<void>
      Internal

      Handle charge update sanity checking, constraining them to reasonable values, and propagating to parent items if charges are shared.

      Parameters

      • changed: object

        Changed data

      • context: object

        Context

      Returns Promise<void>

    _onCreate

    • _onCreate(data: object, context: object, userId: string): void

      Parameters

      • data: object

        Creation data

      • context: object

        Creation context options

      • userId: string

        Triggering user ID

      Returns void

    _onLevelChange

    • _onLevelChange(
          curLevel?: number,
          newLevel?: number,
          options?: { event?: "create" | "update" | "delete" },
      ): Promise<void>

      Add or remove class associations on level change.

      Called from ItemBasePF._onXOperation functions

      Parameters

      • curLevel: number = 0

        Current level, before the change.

      • newLevel: number = 0

        New level, after the change.

      • Optionaloptions: { event?: "create" | "update" | "delete" } = {}

        Additional options

        • Optionalevent?: "create" | "update" | "delete"

          Relevant event

      Returns Promise<void>

    _onUpdate

    • _onUpdate(changed: object, context: object, userId: string): void

      Parameters

      • changed: object

        Changed data

      • context: object

        Context

      • userId: string

        Triggering user ID

      Returns void

    _preCreate

    • _preCreate(data: any, context: any, user: any): Promise<void>

      Parameters

      • data: any
      • context: any
      • user: any

      Returns Promise<void>

    _prepareTraits

    • _prepareTraits(): void
      Internal

      Returns void

    _preUpdate

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

      Parameters

      • changed: object

        Changed data

      • context: object

        Context

      • user: User

        Triggering user

      Returns Promise<void>

    Protected_rechargeActions

    • _rechargeActions(
          options?: { exact: boolean; period?: string; rollData?: object },
      ): undefined | object
      Protected

      Update action limited uses

      {@inheritDoc ItemPF.recharge}

      Parameters

      • options: { exact: boolean; period?: string; rollData?: object } = {}

        Options

        • exact: boolean

          Exact time period only

        • Optionalperiod?: string

          Recharge only if matching this time period

        • OptionalrollData?: object

          Roll data

      Returns undefined | object

      • Update data or undefined if no update is needed.

    Protected_rechargeUses

    • _rechargeUses(
          options?: {
              exact?: boolean;
              maximize?: boolean;
              period?: string;
              rollData?: object;
              value?: number;
          },
      ): Promise<undefined | object>
      Protected

      Recharges item's uses, if any.

      Parameters

      • options: {
            exact?: boolean;
            maximize?: boolean;
            period?: string;
            rollData?: object;
            value?: number;
        } = {}

        Options

        • Optionalexact?: boolean

          Match only exact time period

        • Optionalmaximize?: boolean

          Maximize instead of using recharge formula

        • Optionalperiod?: string

          Recharge only if it matches this time period

        • OptionalrollData?: object

          Roll data instance

        • Optionalvalue?: number

          Set charges to specific value

      Returns Promise<undefined | object>

      • Update data or undefined if no update is necessary.

    _registerOnActor

    • _registerOnActor(): void
      Internal

      Register this item on actor in relevant places.

      Returns void

    _updateChargeLinking

    • _updateChargeLinking(): void
      Internal

      Update Charge Linking

      Returns void

    _updateInheritedCharges

    • _updateInheritedCharges(source: Item<"base" | ModuleSubType>): void
      Internal

      Update this item's charges based on provided item.

      Parameters

      • source: Item<"base" | ModuleSubType>

        Charge source

      Returns void

    • Get default charge cost for all actions.

      Parameters

      • Optionaloptions: { rollData?: object } = {}

        Additional options

        • OptionalrollData?: object

          Roll data instance

      Returns number

      Number for default cost.

    • Default charge formula.

      Returns string

      • Charge formula

    • Called by ()

      Parameters

      • labels: any
      • __namedParameters: {} = {}

      Returns any

    • Visible item name

      Parameters

      • OptionalasPlayer: boolean = false

        If true, return value players see.

      Returns string

      • Item name

    • DataModel specific roll data

      Parameters

      • result: object

        Roll data

      Returns void

    • Prepare data dependent on other items

      Called in actor.prepareDerivedData() when all items are guaranteed to be prepared.

      Returns void

    • Recharges item's uses, if any.

      Parameters

      • options: {
            commit?: boolean;
            context?: object;
            exact?: boolean;
            maximize?: boolean;
            period?: "round" | "minute" | "hour" | "day" | "week" | "any";
            rollData?: object;
            value?: number;
        } = {}

        Options

        • Optionalcommit?: boolean

          Commit update directly. If false, returns the update data instead.

        • Optionalcontext?: object

          Update context

        • Optionalexact?: boolean

          Use exact time period. Otherwise "week" for example will also recharge items with "day" period.

        • Optionalmaximize?: boolean

          Recharge to full regardless of recharge formula.

        • Optionalperiod?: "round" | "minute" | "hour" | "day" | "week" | "any"

          Recharge period. Use "any" to ignore item's configuration.

        • OptionalrollData?: object

          Roll data instance to use for formulas.

        • Optionalvalue?: number

          Recharge to specific value, respecting maximum and minimum bounds.

      Returns Promise<undefined | object | ClassModel>

      • Promise for the update, update data object, or undefined (no update needed).

    • Set item's active state.

      Parameters

      • active: boolean

        Active state

      • Optionalcontext: object

        Optional update context

      Returns Promise<ClassModel>

      • Update promise if item type supports the operation.
      • If item does not support the operation.

    Protected Static Abstract_adjustNewItem

    • _adjustNewItem(item?: ItemPF, data?: object, override?: boolean): void
      Protected

      Adjust temporary item before creation

      Parameters

      • Optionalitem: ItemPF

        Temporary document

      • Optionaldata: object

        Creation data

      • Optionaloverride: boolean = false

        Override values even if defined

      Returns void

    • Returns {
          alignment: StringField<
              DefaultOptions,
              AssignmentType<DefaultOptions>,
              InitializedType<DefaultOptions>,
              InitializedType<DefaultOptions>,
          >;
          armorProf: SetField<
              StringField<
                  { blank: false },
                  AssignmentType<{ blank: false }>,
                  InitializedType<{ blank: false }>,
                  InitializedType<{ blank: false }>,
              >,
              { required: false },
              AssignmentType<{ blank: false }>,
              InitializedType<{ blank: false }>,
              AssignmentType<AssignmentType<{ blank: false }>, { required: false }>,
              InitializedType<InitializedType<{ blank: false }>, { required: false }>,
              InitializedType<{ blank: false }>,
              PersistedType<InitializedType<{ blank: false }>, { required: false }>,
          >;
          bab: StringField<
              { initial: "low" },
              AssignmentType<{ initial: "low" }>,
              InitializedType<{ initial: "low" }>,
              InitializedType<{ initial: "low" }>,
          >;
          babFormula: FormulaField;
          casting: SchemaField<
              {
                  ability: StringField<
                      { nullable: boolean; required: boolean },
                      AssignmentType<{ nullable: boolean; required: boolean }>,
                      InitializedType<{ nullable: boolean; required: boolean }>,
                      InitializedType<{ nullable: boolean; required: boolean }>,
                  >;
                  cantrips: BooleanField<
                      { initial: true; required: false },
                      AssignmentType<
                          SimpleMerge<{ initial: true; required: false }, DefaultOptions>,
                      >,
                      InitializedType<
                          SimpleMerge<{ initial: true; required: false }, DefaultOptions>,
                      >,
                      InitializedType<
                          SimpleMerge<{ initial: true; required: false }, DefaultOptions>,
                      >,
                  >;
                  domain: NumberField<
                      { integer: true; min: 0; required: false },
                      AssignmentType<{ integer: true; min: 0; required: false }>,
                      InitializedType<{ integer: true; min: 0; required: false }>,
                      InitializedType<{ integer: true; min: 0; required: false }>,
                  >;
                  offset: NumberField<
                      { integer: true; required: false },
                      AssignmentType<{ integer: true; required: false }>,
                      InitializedType<{ integer: true; required: false }>,
                      InitializedType<{ integer: true; required: false }>,
                  >;
                  progression: StringField<
                      { nullable: boolean; required: boolean },
                      AssignmentType<{ nullable: boolean; required: boolean }>,
                      InitializedType<{ nullable: boolean; required: boolean }>,
                      InitializedType<{ nullable: boolean; required: boolean }>,
                  >;
                  spells: StringField<
                      { nullable: boolean; required: boolean },
                      AssignmentType<{ nullable: boolean; required: boolean }>,
                      InitializedType<{ nullable: boolean; required: boolean }>,
                      InitializedType<{ nullable: boolean; required: boolean }>,
                  >;
                  type: StringField<
                      { nullable: boolean; required: boolean },
                      AssignmentType<{ nullable: boolean; required: boolean }>,
                      InitializedType<{ nullable: boolean; required: boolean }>,
                      InitializedType<{ nullable: boolean; required: boolean }>,
                  >;
              },
              { required: boolean },
              AssignmentType<
                  {
                      ability: StringField<
                          { nullable: boolean; required: boolean },
                          AssignmentType<{ nullable: boolean; required: boolean }>,
                          InitializedType<{ nullable: boolean; required: boolean }>,
                          InitializedType<{ nullable: boolean; required: boolean }>,
                      >;
                      cantrips: BooleanField<
                          { initial: true; required: false },
                          AssignmentType<
                              SimpleMerge<{ initial: true; required: false }, DefaultOptions>,
                          >,
                          InitializedType<
                              SimpleMerge<{ initial: true; required: false }, DefaultOptions>,
                          >,
                          InitializedType<
                              SimpleMerge<{ initial: true; required: false }, DefaultOptions>,
                          >,
                      >;
                      domain: NumberField<
                          { integer: true; min: 0; required: false },
                          AssignmentType<{ integer: true; min: 0; required: false }>,
                          InitializedType<{ integer: true; min: 0; required: false }>,
                          InitializedType<{ integer: true; min: 0; required: false }>,
                      >;
                      offset: NumberField<
                          { integer: true; required: false },
                          AssignmentType<{ integer: true; required: false }>,
                          InitializedType<{ integer: true; required: false }>,
                          InitializedType<{ integer: true; required: false }>,
                      >;
                      progression: StringField<
                          { nullable: boolean; required: boolean },
                          AssignmentType<{ nullable: boolean; required: boolean }>,
                          InitializedType<{ nullable: boolean; required: boolean }>,
                          InitializedType<{ nullable: boolean; required: boolean }>,
                      >;
                      spells: StringField<
                          { nullable: boolean; required: boolean },
                          AssignmentType<{ nullable: boolean; required: boolean }>,
                          InitializedType<{ nullable: boolean; required: boolean }>,
                          InitializedType<{ nullable: boolean; required: boolean }>,
                      >;
                      type: StringField<
                          { nullable: boolean; required: boolean },
                          AssignmentType<{ nullable: boolean; required: boolean }>,
                          InitializedType<{ nullable: boolean; required: boolean }>,
                          InitializedType<{ nullable: boolean; required: boolean }>,
                      >;
                  },
                  SimpleMerge<{ required: boolean }, DefaultOptions>,
              >,
              {
                  ability: InitializedType<{ nullable: boolean; required: boolean }>;
                  cantrips: InitializedType<
                      SimpleMerge<{ initial: true; required: false }, DefaultOptions>,
                  >;
                  domain: InitializedType<{ integer: true; min: 0; required: false }>;
                  offset: InitializedType<{ integer: true; required: false }>;
                  progression: InitializedType<{ nullable: boolean; required: boolean }>;
                  spells: InitializedType<{ nullable: boolean; required: boolean }>;
                  type: InitializedType<{ nullable: boolean; required: boolean }>;
              },
              {
                  ability: InitializedType<{ nullable: boolean; required: boolean }>;
                  cantrips: InitializedType<
                      SimpleMerge<{ initial: true; required: false }, DefaultOptions>,
                  >;
                  domain: InitializedType<{ integer: true; min: 0; required: false }>;
                  offset: InitializedType<{ integer: true; required: false }>;
                  progression: InitializedType<{ nullable: boolean; required: boolean }>;
                  spells: InitializedType<{ nullable: boolean; required: boolean }>;
                  type: InitializedType<{ nullable: boolean; required: boolean }>;
              },
          >;
          changeFlags: SetField<
              StringField<
                  { blank: false },
                  AssignmentType<{ blank: false }>,
                  InitializedType<{ blank: false }>,
                  InitializedType<{ blank: false }>,
              >,
              { required: false },
              AssignmentType<{ blank: false }>,
              InitializedType<{ blank: false }>,
              AssignmentType<AssignmentType<{ blank: false }>, { required: false }>,
              InitializedType<InitializedType<{ blank: false }>, { required: false }>,
              InitializedType<{ blank: false }>,
              PersistedType<InitializedType<{ blank: false }>, { required: false }>,
          >;
          changes: ArrayField<
              EmbeddedDataField<
                  AnyConstructor,
                  DefaultOptions,
                  AssignmentType<AnyConstructor, DefaultOptions>,
                  AnyDataModel,
                  {},
              >,
              { required: false },
              AssignmentType<AnyConstructor, DefaultOptions>,
              AnyDataModel,
              AssignmentType<
                  AssignmentType<AnyConstructor, DefaultOptions>,
                  { required: false },
              >,
              InitializedType<AnyDataModel, { required: false }>,
              {},
              PersistedType<{}, { required: false }>,
          >;
          ci: SetField<
              StringField<
                  { blank: false },
                  AssignmentType<{ blank: false }>,
                  InitializedType<{ blank: false }>,
                  InitializedType<{ blank: false }>,
              >,
              { required: false },
              AssignmentType<{ blank: false }>,
              InitializedType<{ blank: false }>,
              AssignmentType<AssignmentType<{ blank: false }>, { required: false }>,
              InitializedType<InitializedType<{ blank: false }>, { required: false }>,
              InitializedType<{ blank: false }>,
              PersistedType<InitializedType<{ blank: false }>, { required: false }>,
          >;
          classSkills: SetField<
              StringField<
                  { blank: false },
                  AssignmentType<{ blank: false }>,
                  InitializedType<{ blank: false }>,
                  InitializedType<{ blank: false }>,
              >,
              { required: false },
              AssignmentType<{ blank: false }>,
              InitializedType<{ blank: false }>,
              AssignmentType<AssignmentType<{ blank: false }>, { required: false }>,
              InitializedType<InitializedType<{ blank: false }>, { required: false }>,
              InitializedType<{ blank: false }>,
              PersistedType<InitializedType<{ blank: false }>, { required: false }>,
          >;
          config: SchemaField<
              {
                  chatSummary: BooleanField<
                      { required: boolean },
                      AssignmentType<SimpleMerge<{ required: boolean }, DefaultOptions>>,
                      InitializedType<SimpleMerge<{ required: boolean }, DefaultOptions>>,
                      InitializedType<SimpleMerge<{ required: boolean }, DefaultOptions>>,
                  >;
              },
              { required: boolean },
              AssignmentType<
                  {
                      chatSummary: BooleanField<
                          { required: boolean },
                          AssignmentType<SimpleMerge<{ required: boolean }, DefaultOptions>>,
                          InitializedType<SimpleMerge<{ required: boolean }, DefaultOptions>>,
                          InitializedType<SimpleMerge<{ required: boolean }, DefaultOptions>>,
                      >;
                  },
                  SimpleMerge<{ required: boolean }, DefaultOptions>,
              >,
              {
                  chatSummary: InitializedType<
                      SimpleMerge<{ required: boolean }, DefaultOptions>,
                  >;
              },
              {
                  chatSummary: InitializedType<
                      SimpleMerge<{ required: boolean }, DefaultOptions>,
                  >;
              },
          >;
          contextNotes: ArrayField<
              EmbeddedDataField<
                  typeof ContextNote,
                  DefaultOptions,
                  AssignmentType<typeof ContextNote, DefaultOptions>,
                  ContextNote,
                  {
                      target: InitializedType<
                          { blank: true; initial: ""; nullable: false },
                      >;
                      text: InitializedType<{ blank: true; initial: ""; nullable: false }>;
                  },
              >,
              { required: false },
              AssignmentType<typeof ContextNote, DefaultOptions>,
              ContextNote,
              AssignmentType<
                  AssignmentType<typeof ContextNote, DefaultOptions>,
                  { required: false },
              >,
              InitializedType<ContextNote, { required: false }>,
              {
                  target: InitializedType<{ blank: true; initial: ""; nullable: false }>;
                  text: InitializedType<{ blank: true; initial: ""; nullable: false }>;
              },
              PersistedType<
                  {
                      target: InitializedType<
                          { blank: true; initial: ""; nullable: false },
                      >;
                      text: InitializedType<{ blank: true; initial: ""; nullable: false }>;
                  },
                  { required: false },
              >,
          >;
          creatureSubtypes: SetField<
              StringField<
                  DefaultOptions,
                  AssignmentType<DefaultOptions>,
                  InitializedType<DefaultOptions>,
                  InitializedType<DefaultOptions>,
              >,
              { required: false },
              AssignmentType<DefaultOptions>,
              InitializedType<DefaultOptions>,
              AssignmentType<AssignmentType<DefaultOptions>, { required: false }>,
              InitializedType<InitializedType<DefaultOptions>, { required: false }>,
              InitializedType<DefaultOptions>,
              PersistedType<InitializedType<DefaultOptions>, { required: false }>,
          >;
          creatureTypes: SetField<
              StringField<
                  DefaultOptions,
                  AssignmentType<DefaultOptions>,
                  InitializedType<DefaultOptions>,
                  InitializedType<DefaultOptions>,
              >,
              { required: false },
              AssignmentType<DefaultOptions>,
              InitializedType<DefaultOptions>,
              AssignmentType<AssignmentType<DefaultOptions>, { required: false }>,
              InitializedType<InitializedType<DefaultOptions>, { required: false }>,
              InitializedType<DefaultOptions>,
              PersistedType<InitializedType<DefaultOptions>, { required: false }>,
          >;
          customHD: FormulaField;
          description: SchemaField<
              {
                  instructions: HTMLField<
                      { nullable: boolean; required: boolean },
                      AssignmentType<{ nullable: boolean; required: boolean }>,
                      InitializedType<{ nullable: boolean; required: boolean }>,
                      InitializedType<{ nullable: boolean; required: boolean }>,
                  >;
                  summary: StringField<
                      { nullable: boolean; required: boolean },
                      AssignmentType<{ nullable: boolean; required: boolean }>,
                      InitializedType<{ nullable: boolean; required: boolean }>,
                      InitializedType<{ nullable: boolean; required: boolean }>,
                  >;
                  value: HTMLField<
                      { nullable: boolean; required: boolean },
                      AssignmentType<{ nullable: boolean; required: boolean }>,
                      InitializedType<{ nullable: boolean; required: boolean }>,
                      InitializedType<{ nullable: boolean; required: boolean }>,
                  >;
              },
              { required: boolean },
              AssignmentType<
                  {
                      instructions: HTMLField<
                          { nullable: boolean; required: boolean },
                          AssignmentType<{ nullable: boolean; required: boolean }>,
                          InitializedType<{ nullable: boolean; required: boolean }>,
                          InitializedType<{ nullable: boolean; required: boolean }>,
                      >;
                      summary: StringField<
                          { nullable: boolean; required: boolean },
                          AssignmentType<{ nullable: boolean; required: boolean }>,
                          InitializedType<{ nullable: boolean; required: boolean }>,
                          InitializedType<{ nullable: boolean; required: boolean }>,
                      >;
                      value: HTMLField<
                          { nullable: boolean; required: boolean },
                          AssignmentType<{ nullable: boolean; required: boolean }>,
                          InitializedType<{ nullable: boolean; required: boolean }>,
                          InitializedType<{ nullable: boolean; required: boolean }>,
                      >;
                  },
                  SimpleMerge<{ required: boolean }, DefaultOptions>,
              >,
              {
                  instructions: InitializedType<
                      { nullable: boolean; required: boolean },
                  >;
                  summary: InitializedType<{ nullable: boolean; required: boolean }>;
                  value: InitializedType<{ nullable: boolean; required: boolean }>;
              },
              {
                  instructions: InitializedType<
                      { nullable: boolean; required: boolean },
                  >;
                  summary: InitializedType<{ nullable: boolean; required: boolean }>;
                  value: InitializedType<{ nullable: boolean; required: boolean }>;
              },
          >;
          di: SetField<
              StringField<
                  { blank: false },
                  AssignmentType<{ blank: false }>,
                  InitializedType<{ blank: false }>,
                  InitializedType<{ blank: false }>,
              >,
              { required: false },
              AssignmentType<{ blank: false }>,
              InitializedType<{ blank: false }>,
              AssignmentType<AssignmentType<{ blank: false }>, { required: false }>,
              InitializedType<InitializedType<{ blank: false }>, { required: false }>,
              InitializedType<{ blank: false }>,
              PersistedType<InitializedType<{ blank: false }>, { required: false }>,
          >;
          dv: SetField<
              StringField<
                  { blank: false },
                  AssignmentType<{ blank: false }>,
                  InitializedType<{ blank: false }>,
                  InitializedType<{ blank: false }>,
              >,
              { required: false },
              AssignmentType<{ blank: false }>,
              InitializedType<{ blank: false }>,
              AssignmentType<AssignmentType<{ blank: false }>, { required: false }>,
              InitializedType<InitializedType<{ blank: false }>, { required: false }>,
              InitializedType<{ blank: false }>,
              PersistedType<InitializedType<{ blank: false }>, { required: false }>,
          >;
          fc: SchemaField<
              {
                  alt: SchemaField<
                      {
                          notes: StringField<
                              DefaultOptions,
                              AssignmentType<DefaultOptions>,
                              InitializedType<DefaultOptions>,
                              InitializedType<DefaultOptions>,
                          >;
                          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 }>,
                          >;
                      },
                      { required: boolean },
                      AssignmentType<
                          {
                              notes: StringField<
                                  DefaultOptions,
                                  AssignmentType<DefaultOptions>,
                                  InitializedType<DefaultOptions>,
                                  InitializedType<DefaultOptions>,
                              >;
                              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<{ required: boolean }, DefaultOptions>,
                      >,
                      {
                          notes: InitializedType<DefaultOptions>;
                          value: InitializedType<{ initial: 0; integer: true; min: 0 }>;
                      },
                      {
                          notes: InitializedType<DefaultOptions>;
                          value: InitializedType<{ initial: 0; integer: true; min: 0 }>;
                      },
                  >;
                  hp: 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 }>,
                          >;
                      },
                      { required: boolean },
                      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<{ required: boolean }, DefaultOptions>,
                      >,
                      { value: InitializedType<{ initial: 0; integer: true; min: 0 }> },
                      { value: InitializedType<{ initial: 0; integer: true; min: 0 }> },
                  >;
                  skill: 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 }>,
                          >;
                      },
                      { required: boolean },
                      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<{ required: boolean }, DefaultOptions>,
                      >,
                      { value: InitializedType<{ initial: 0; integer: true; min: 0 }> },
                      { value: InitializedType<{ initial: 0; integer: true; min: 0 }> },
                  >;
              },
              { required: boolean },
              AssignmentType<
                  {
                      alt: SchemaField<
                          {
                              notes: StringField<
                                  DefaultOptions,
                                  AssignmentType<DefaultOptions>,
                                  InitializedType<DefaultOptions>,
                                  InitializedType<DefaultOptions>,
                              >;
                              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 }>,
                              >;
                          },
                          { required: boolean },
                          AssignmentType<
                              {
                                  notes: StringField<
                                      DefaultOptions,
                                      AssignmentType<DefaultOptions>,
                                      InitializedType<DefaultOptions>,
                                      InitializedType<DefaultOptions>,
                                  >;
                                  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<{ required: boolean }, DefaultOptions>,
                          >,
                          {
                              notes: InitializedType<DefaultOptions>;
                              value: InitializedType<{ initial: 0; integer: true; min: 0 }>;
                          },
                          {
                              notes: InitializedType<DefaultOptions>;
                              value: InitializedType<{ initial: 0; integer: true; min: 0 }>;
                          },
                      >;
                      hp: 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 }>,
                              >;
                          },
                          { required: boolean },
                          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<{ required: boolean }, DefaultOptions>,
                          >,
                          { value: InitializedType<{ initial: 0; integer: true; min: 0 }> },
                          { value: InitializedType<{ initial: 0; integer: true; min: 0 }> },
                      >;
                      skill: 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 }>,
                              >;
                          },
                          { required: boolean },
                          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<{ required: boolean }, DefaultOptions>,
                          >,
                          { value: InitializedType<{ initial: 0; integer: true; min: 0 }> },
                          { value: InitializedType<{ initial: 0; integer: true; min: 0 }> },
                      >;
                  },
                  SimpleMerge<{ required: boolean }, DefaultOptions>,
              >,
              {
                  alt: {
                      notes: InitializedType<DefaultOptions>;
                      value: InitializedType<{ initial: 0; integer: true; min: 0 }>;
                  };
                  hp: { value: InitializedType<{ initial: 0; integer: true; min: 0 }> };
                  skill: { value: InitializedType<{ initial: 0; integer: true; min: 0 }> };
              },
              {
                  alt: {
                      notes: InitializedType<DefaultOptions>;
                      value: InitializedType<{ initial: 0; integer: true; min: 0 }>;
                  };
                  hp: { value: InitializedType<{ initial: 0; integer: true; min: 0 }> };
                  skill: { value: InitializedType<{ initial: 0; integer: true; min: 0 }> };
              },
          >;
          flags: SchemaField<
              {
                  boolean: ObjectField<
                      { required: false },
                      AssignmentType<{ required: false }>,
                      InitializedType<{ required: false }>,
                      InitializedType<{ required: false }>,
                  >;
                  dictionary: ObjectField<
                      { required: false },
                      AssignmentType<{ required: false }>,
                      InitializedType<{ required: false }>,
                      InitializedType<{ required: false }>,
                  >;
              },
              { required: false },
              AssignmentType<
                  {
                      boolean: ObjectField<
                          { required: false },
                          AssignmentType<{ required: false }>,
                          InitializedType<{ required: false }>,
                          InitializedType<{ required: false }>,
                      >;
                      dictionary: ObjectField<
                          { required: false },
                          AssignmentType<{ required: false }>,
                          InitializedType<{ required: false }>,
                          InitializedType<{ required: false }>,
                      >;
                  },
                  SimpleMerge<{ required: false }, DefaultOptions>,
              >,
              {
                  boolean: InitializedType<{ required: false }>;
                  dictionary: InitializedType<{ required: false }>;
              },
              {
                  boolean: InitializedType<{ required: false }>;
                  dictionary: InitializedType<{ required: false }>;
              },
          >;
          hd: NumberField<
              { initial: 8; integer: true; min: 0; nullable: false },
              AssignmentType<{ initial: 8; integer: true; min: 0; nullable: false }>,
              InitializedType<{ initial: 8; integer: true; min: 0; nullable: false }>,
              InitializedType<{ initial: 8; integer: true; min: 0; nullable: false }>,
          >;
          hp: NumberField<
              { integer: true; min: 0; nullable: false; required: false },
              AssignmentType<
                  { integer: true; min: 0; nullable: false; required: false },
              >,
              InitializedType<
                  { integer: true; min: 0; nullable: false; required: false },
              >,
              InitializedType<
                  { integer: true; min: 0; nullable: false; required: false },
              >,
          >;
          languages: SetField<
              StringField<
                  { blank: false },
                  AssignmentType<{ blank: false }>,
                  InitializedType<{ blank: false }>,
                  InitializedType<{ blank: false }>,
              >,
              { required: false },
              AssignmentType<{ blank: false }>,
              InitializedType<{ blank: false }>,
              AssignmentType<AssignmentType<{ blank: false }>, { required: false }>,
              InitializedType<InitializedType<{ blank: false }>, { required: false }>,
              InitializedType<{ blank: false }>,
              PersistedType<InitializedType<{ blank: false }>, { required: false }>,
          >;
          level: NumberField<
              { initial: 1; integer: true; min: 0; nullable: false },
              AssignmentType<{ initial: 1; integer: true; min: 0; nullable: false }>,
              InitializedType<{ initial: 1; integer: true; min: 0; nullable: false }>,
              InitializedType<{ initial: 1; integer: true; min: 0; nullable: false }>,
          >;
          links: SchemaField<
              {
                  children: ArrayField<
                      EmbeddedDataField<
                          AnyConstructor,
                          DefaultOptions,
                          AssignmentType<AnyConstructor, DefaultOptions>,
                          AnyDataModel,
                          {},
                      >,
                      { required: false },
                      AssignmentType<AnyConstructor, DefaultOptions>,
                      AnyDataModel,
                      AssignmentType<
                          AssignmentType<AnyConstructor, DefaultOptions>,
                          { required: false },
                      >,
                      InitializedType<AnyDataModel, { required: false }>,
                      {},
                      PersistedType<{}, { required: false }>,
                  >;
                  supplements: ArrayField<
                      EmbeddedDataField<
                          AnyConstructor,
                          DefaultOptions,
                          AssignmentType<AnyConstructor, DefaultOptions>,
                          AnyDataModel,
                          {},
                      >,
                      { required: false },
                      AssignmentType<AnyConstructor, DefaultOptions>,
                      AnyDataModel,
                      AssignmentType<
                          AssignmentType<AnyConstructor, DefaultOptions>,
                          { required: false },
                      >,
                      InitializedType<AnyDataModel, { required: false }>,
                      {},
                      PersistedType<{}, { required: false }>,
                  >;
              },
              { required: boolean },
              AssignmentType<
                  {
                      children: ArrayField<
                          EmbeddedDataField<
                              AnyConstructor,
                              DefaultOptions,
                              AssignmentType<AnyConstructor, DefaultOptions>,
                              AnyDataModel,
                              {},
                          >,
                          { required: false },
                          AssignmentType<AnyConstructor, DefaultOptions>,
                          AnyDataModel,
                          AssignmentType<
                              AssignmentType<AnyConstructor, DefaultOptions>,
                              { required: false },
                          >,
                          InitializedType<AnyDataModel, { required: false }>,
                          {},
                          PersistedType<{}, { required: false }>,
                      >;
                      supplements: ArrayField<
                          EmbeddedDataField<
                              AnyConstructor,
                              DefaultOptions,
                              AssignmentType<AnyConstructor, DefaultOptions>,
                              AnyDataModel,
                              {},
                          >,
                          { required: false },
                          AssignmentType<AnyConstructor, DefaultOptions>,
                          AnyDataModel,
                          AssignmentType<
                              AssignmentType<AnyConstructor, DefaultOptions>,
                              { required: false },
                          >,
                          InitializedType<AnyDataModel, { required: false }>,
                          {},
                          PersistedType<{}, { required: false }>,
                      >;
                  },
                  SimpleMerge<{ required: boolean }, DefaultOptions>,
              >,
              {
                  children: InitializedType<AnyDataModel, { required: false }>;
                  supplements: InitializedType<AnyDataModel, { required: false }>;
              },
              {
                  children: PersistedType<{}, { required: false }>;
                  supplements: PersistedType<{}, { required: false }>;
              },
          >;
          savingThrows: SchemaField<
              {
                  fort: SchemaField<
                      {
                          custom: FormulaField;
                          value: StringField<
                              { initial: "low" },
                              AssignmentType<{ initial: "low" }>,
                              InitializedType<{ initial: "low" }>,
                              InitializedType<{ initial: "low" }>,
                          >;
                      },
                      DefaultOptions,
                      AssignmentType<
                          {
                              custom: FormulaField;
                              value: StringField<
                                  { initial: "low" },
                                  AssignmentType<{ initial: "low" }>,
                                  InitializedType<{ initial: "low" }>,
                                  InitializedType<{ initial: "low" }>,
                              >;
                          },
                          SimpleMerge<DefaultOptions, DefaultOptions>,
                      >,
                      {
                          custom: InitializedType<DefaultOptions>;
                          value: InitializedType<{ initial: "low" }>;
                      },
                      {
                          custom: InitializedType<DefaultOptions>;
                          value: InitializedType<{ initial: "low" }>;
                      },
                  >;
                  ref: SchemaField<
                      {
                          custom: FormulaField;
                          value: StringField<
                              { initial: "low" },
                              AssignmentType<{ initial: "low" }>,
                              InitializedType<{ initial: "low" }>,
                              InitializedType<{ initial: "low" }>,
                          >;
                      },
                      DefaultOptions,
                      AssignmentType<
                          {
                              custom: FormulaField;
                              value: StringField<
                                  { initial: "low" },
                                  AssignmentType<{ initial: "low" }>,
                                  InitializedType<{ initial: "low" }>,
                                  InitializedType<{ initial: "low" }>,
                              >;
                          },
                          SimpleMerge<DefaultOptions, DefaultOptions>,
                      >,
                      {
                          custom: InitializedType<DefaultOptions>;
                          value: InitializedType<{ initial: "low" }>;
                      },
                      {
                          custom: InitializedType<DefaultOptions>;
                          value: InitializedType<{ initial: "low" }>;
                      },
                  >;
                  will: SchemaField<
                      {
                          custom: FormulaField;
                          value: StringField<
                              { initial: "low" },
                              AssignmentType<{ initial: "low" }>,
                              InitializedType<{ initial: "low" }>,
                              InitializedType<{ initial: "low" }>,
                          >;
                      },
                      DefaultOptions,
                      AssignmentType<
                          {
                              custom: FormulaField;
                              value: StringField<
                                  { initial: "low" },
                                  AssignmentType<{ initial: "low" }>,
                                  InitializedType<{ initial: "low" }>,
                                  InitializedType<{ initial: "low" }>,
                              >;
                          },
                          SimpleMerge<DefaultOptions, DefaultOptions>,
                      >,
                      {
                          custom: InitializedType<DefaultOptions>;
                          value: InitializedType<{ initial: "low" }>;
                      },
                      {
                          custom: InitializedType<DefaultOptions>;
                          value: InitializedType<{ initial: "low" }>;
                      },
                  >;
              },
              DefaultOptions,
              AssignmentType<
                  {
                      fort: SchemaField<
                          {
                              custom: FormulaField;
                              value: StringField<
                                  { initial: "low" },
                                  AssignmentType<{ initial: "low" }>,
                                  InitializedType<{ initial: "low" }>,
                                  InitializedType<{ initial: "low" }>,
                              >;
                          },
                          DefaultOptions,
                          AssignmentType<
                              {
                                  custom: FormulaField;
                                  value: StringField<
                                      { initial: "low" },
                                      AssignmentType<{ initial: "low" }>,
                                      InitializedType<{ initial: "low" }>,
                                      InitializedType<{ initial: "low" }>,
                                  >;
                              },
                              SimpleMerge<DefaultOptions, DefaultOptions>,
                          >,
                          {
                              custom: InitializedType<DefaultOptions>;
                              value: InitializedType<{ initial: "low" }>;
                          },
                          {
                              custom: InitializedType<DefaultOptions>;
                              value: InitializedType<{ initial: "low" }>;
                          },
                      >;
                      ref: SchemaField<
                          {
                              custom: FormulaField;
                              value: StringField<
                                  { initial: "low" },
                                  AssignmentType<{ initial: "low" }>,
                                  InitializedType<{ initial: "low" }>,
                                  InitializedType<{ initial: "low" }>,
                              >;
                          },
                          DefaultOptions,
                          AssignmentType<
                              {
                                  custom: FormulaField;
                                  value: StringField<
                                      { initial: "low" },
                                      AssignmentType<{ initial: "low" }>,
                                      InitializedType<{ initial: "low" }>,
                                      InitializedType<{ initial: "low" }>,
                                  >;
                              },
                              SimpleMerge<DefaultOptions, DefaultOptions>,
                          >,
                          {
                              custom: InitializedType<DefaultOptions>;
                              value: InitializedType<{ initial: "low" }>;
                          },
                          {
                              custom: InitializedType<DefaultOptions>;
                              value: InitializedType<{ initial: "low" }>;
                          },
                      >;
                      will: SchemaField<
                          {
                              custom: FormulaField;
                              value: StringField<
                                  { initial: "low" },
                                  AssignmentType<{ initial: "low" }>,
                                  InitializedType<{ initial: "low" }>,
                                  InitializedType<{ initial: "low" }>,
                              >;
                          },
                          DefaultOptions,
                          AssignmentType<
                              {
                                  custom: FormulaField;
                                  value: StringField<
                                      { initial: "low" },
                                      AssignmentType<{ initial: "low" }>,
                                      InitializedType<{ initial: "low" }>,
                                      InitializedType<{ initial: "low" }>,
                                  >;
                              },
                              SimpleMerge<DefaultOptions, DefaultOptions>,
                          >,
                          {
                              custom: InitializedType<DefaultOptions>;
                              value: InitializedType<{ initial: "low" }>;
                          },
                          {
                              custom: InitializedType<DefaultOptions>;
                              value: InitializedType<{ initial: "low" }>;
                          },
                      >;
                  },
                  SimpleMerge<DefaultOptions, DefaultOptions>,
              >,
              {
                  fort: {
                      custom: InitializedType<DefaultOptions>;
                      value: InitializedType<{ initial: "low" }>;
                  };
                  ref: {
                      custom: InitializedType<DefaultOptions>;
                      value: InitializedType<{ initial: "low" }>;
                  };
                  will: {
                      custom: InitializedType<DefaultOptions>;
                      value: InitializedType<{ initial: "low" }>;
                  };
              },
              {
                  fort: {
                      custom: InitializedType<DefaultOptions>;
                      value: InitializedType<{ initial: "low" }>;
                  };
                  ref: {
                      custom: InitializedType<DefaultOptions>;
                      value: InitializedType<{ initial: "low" }>;
                  };
                  will: {
                      custom: InitializedType<DefaultOptions>;
                      value: InitializedType<{ initial: "low" }>;
                  };
              },
          >;
          scriptCalls: ArrayField<
              EmbeddedDataField<
                  AnyConstructor,
                  DefaultOptions,
                  AssignmentType<AnyConstructor, DefaultOptions>,
                  AnyDataModel,
                  {},
              >,
              { required: false },
              AssignmentType<AnyConstructor, DefaultOptions>,
              AnyDataModel,
              AssignmentType<
                  AssignmentType<AnyConstructor, DefaultOptions>,
                  { required: false },
              >,
              InitializedType<AnyDataModel, { required: false }>,
              {},
              PersistedType<{}, { required: false }>,
          >;
          skillsPerLevel: NumberField<
              { initial: 0; integer: true; min: 0; nullable: false },
              AssignmentType<{ initial: 0; integer: true; min: 0; nullable: false }>,
              InitializedType<{ initial: 0; integer: true; min: 0; nullable: false }>,
              InitializedType<{ initial: 0; integer: true; min: 0; nullable: false }>,
          >;
          sources: ArrayField<
              EmbeddedDataField<
                  AnyConstructor,
                  DefaultOptions,
                  AssignmentType<AnyConstructor, DefaultOptions>,
                  AnyDataModel,
                  {},
              >,
              { required: false },
              AssignmentType<AnyConstructor, DefaultOptions>,
              AnyDataModel,
              AssignmentType<
                  AssignmentType<AnyConstructor, DefaultOptions>,
                  { required: false },
              >,
              InitializedType<AnyDataModel, { required: false }>,
              {},
              PersistedType<{}, { required: false }>,
          >;
          subType: StringField<
              { blank: boolean; initial: any; nullable: boolean },
              any,
              InitializedType<{ blank: boolean; initial: any; nullable: boolean }>,
              InitializedType<{ blank: boolean; initial: any; nullable: boolean }>,
          >;
          tag: StringField<
              { nullable: boolean; required: boolean },
              AssignmentType<{ nullable: boolean; required: boolean }>,
              InitializedType<{ nullable: boolean; required: boolean }>,
              InitializedType<{ nullable: boolean; required: boolean }>,
          >;
          tags: SetField<
              StringField<
                  { blank: false },
                  AssignmentType<{ blank: false }>,
                  InitializedType<{ blank: false }>,
                  InitializedType<{ blank: false }>,
              >,
              { required: boolean },
              AssignmentType<{ blank: false }>,
              InitializedType<{ blank: false }>,
              AssignmentType<AssignmentType<{ blank: false }>, { required: boolean }>,
              InitializedType<InitializedType<{ blank: false }>, { required: boolean }>,
              InitializedType<{ blank: false }>,
              PersistedType<InitializedType<{ blank: false }>, { required: boolean }>,
          >;
          wealth: FormulaField;
          weaponProf: SetField<
              StringField<
                  { blank: false },
                  AssignmentType<{ blank: false }>,
                  InitializedType<{ blank: false }>,
                  InitializedType<{ blank: false }>,
              >,
              { required: false },
              AssignmentType<{ blank: false }>,
              InitializedType<{ blank: false }>,
              AssignmentType<AssignmentType<{ blank: false }>, { required: false }>,
              InitializedType<InitializedType<{ blank: false }>, { required: false }>,
              InitializedType<{ blank: false }>,
              PersistedType<InitializedType<{ blank: false }>, { required: false }>,
          >;
      }

    • Parameters

      • source: any

      Returns any

    • Parent datamodel (item document) migration

      AVOID USING THIS

      Parameters

      • _source: object

        Document source data

      Returns void

    • Parameters

      • source: any

      Returns void

    Settings

    Member Visibility

    On This Page

    Constructors
    Properties
    Accessors
    Methods