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

    Class ImplantModel

    Basic Item model with actions and related data

    Hierarchy (View Summary)

    Index

    Constructors

    Properties

    actions?: ItemAction[]
    armorProf?: Set<string>
    artifact: boolean

    false

    attackNotes?: string[]
    aura?: { custom?: boolean; school?: string }
    broken: boolean
    carried: undefined | boolean

    true

    changeFlags?: Set<string>
    changes?: ItemChange[]
    cl: null | number

    Caster Level

    null

    classSkills?: Set<string>
    contextNotes?: ContextNote[]
    cursed: boolean

    false

    description?: { instructions?: string; summary?: string; value?: string }
    effectNotes?: string[]
    equipped: undefined | boolean

    true

    flags?: { boolean?: {}; dictionary?: {} }
    hardness?: { base: any; total: any }
    hp: { base: number; max: number; value: number }
    identified: boolean

    true

    implant?: number

    Implantation cost

    implanted?: boolean

    Is this implanted?

    install?: number

    Install DC

    languages?: Set<string>
    links?: { children?: LinkModel[]; supplements?: LinkModel[] }
    nonhumanoid: boolean
    parent?: ItemPF
    price?: number
    quantity: number
    resizing: boolean
    scriptCalls?: ItemScriptCall[]
    showInCombat?: boolean

    Show item in combat tab.

    showInQuickbar?: boolean

    Display item and its actions in quick actions and token HUD.

    size: "dim" | "med" | "fine" | "tiny" | "sm" | "lg" | "huge" | "grg" | "col"
    slot?: "none" | "head" | "eyes" | "body" | "arm" | "brain" | "ears" | "legs"

    Slot

    subType?: string
    tag?: string
    timeworn: boolean

    false

    unidentified?: { name?: string; price?: number }
    weaponProf?: Set<string>
    weight: { value?: number }
    metadata: Readonly<
        {
            activeState: "implanted";
            isPhysical: true;
            label: "CONFIG.Item.typeLabels.implant";
            type: "implant";
        },
    > = ...

    Accessors

    • get activeState(): boolean

      Active state as per what setActive would correspond with.

      Returns boolean

    • get addonMaterial(): Set<string>

      The item's material addons.

      Returns Set<string>

    • get autoDeductCharges(): boolean

      Consumes are adds charges by default.

      Returns boolean

    • get baseMaterial(): null | string

      Base material

      Returns null | string

    • get canEquip(): boolean

      Can equip currently?

      Returns boolean

    • get canUse(): undefined | boolean

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

      Returns undefined | boolean

    • get charges(): number

      Remaining charges

      Returns number

    • get defaultSchool(): null | string

      The default spell school of this items aura, if any

      Returns null | string

    • get effectiveCl(): number

      Effective caster level of this item.

      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

    • get isBroken(): boolean

      Broken state

      Tests both explicit broken override and current health.

      Returns boolean

    • get isCharged(): boolean

      Returns boolean

    • get isProficient(): boolean

      Is the owning actor proficiency at using this as weapon.

      Returns boolean

      PF1 v10

    • 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.
    • get normalMaterial(): null | string

      The item's actual material.

      Returns null | string

    • get showIdentified(): boolean

      Should current user see identified info

      Returns boolean

    Methods

    • 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: any

      Returns any

    • 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>

    • Internal

      Finalize weight calculation effects

      Returns void

    • Returns 0.5 | 1 | 2 | 4 | 8 | 16 | 32

    • Internal

      Weight scaling

      For use with () across item types

      Returns number

      • Weight multiplier
    • Parameters

      • data: any
      • context: any
      • userId: any

      Returns void

    • Internal

      Parameters

      • context: object

        Context

      • userId: string

        Triggering user ID

      Returns void

    • Parameters

      • changed: object

        Changed data

      • context: object

        Context

      • userId: string

        Triggering user ID

      Returns void

    • Parameters

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

      Returns Promise<void>

    • Parameters

      • changed: object

        Changed data

      • context: object

        Context

      • user: User

        Triggering user

      Returns Promise<void>

    • 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

      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.
    • Reset charges when quantity is changed to simulate a stack.

      • If charges are 0
      • ... and quantity is reduced, reset to max

      Parameters

      • changed: object

        Changed data

      Returns Promise<void>

    • Internal

      Update this item's charges based on provided item.

      Parameters

      • source: Item<"base" | ModuleSubType>

        Charge source

      Returns void

    • Return cost multiplier affecting this item.

      Such as item size dictating how costly an armor is.

      Returns number

      • Multiplier, 1 for most items regardless of size.
    • Get default charge cost for all actions.

      Parameters

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

        Additional options

        • OptionalrollData?: object

          Roll data instance

      Returns number

      Number for default cost.

    • Protected

      Called by ()

      Parameters

      • labels: object
      • Optionaloptions: { isolated?: boolean; rollData?: object } = {}

      Returns void

    • Visible item name

      Parameters

      • asPlayer: boolean = false

        If true, return value players see.

      Returns string

      • Item name
    • Parameters

      • Optional_weapon: boolean = true

        Get proficiency as a weapon. Armor otherwise.

      Returns boolean

      • Whether or not the owner of the item is proficient.
      • If item type does not support proficiency.

      PF1 v10

    • DataModel specific roll data

      Parameters

      • result: any

        Roll data

      Returns void

    • Returns the displayed value of an item according to multiple options

      Parameters

      • Optionaloptions: {
            forceUnidentified?: boolean;
            identical?: boolean;
            inLowestDenomination?: boolean;
            maximized?: boolean;
            ratio: any;
            recursive?: boolean;
            sellValue?: number;
            single?: boolean;
        } = {}

        Various optional parameters affecting value calculations

        • OptionalforceUnidentified?: boolean

          Override whether the value should use the unidentified price

        • Optionalidentical?: boolean

          Treat all items in stack as identical (same number of charges).

        • OptionalinLowestDenomination?: boolean

          Whether the value should be returned in the lowest denomination

        • Optionalmaximized?: boolean

          Pretend as if the items were fresh (full charges)

        • ratio: any
        • Optionalrecursive?: boolean

          Whether the value of contained items should be included

        • OptionalsellValue?: number

          The sell value multiplier

        • Optionalsingle?: boolean

          Return value of singular item instead of the actual stack. Disables recursive option.

      Returns number

      The item's value

    • Return weight multiplier affecting this item.

      Such as item size dictating how heavy an armor is.

      Returns number

      • Multiplier, 1 for most items regardless of size.
    • Prepare data dependent on other items

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

      Returns void

    • Internal

      Prepare hardness and hit points

      Returns void

    • Prepare this item's WeightData

      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 | ImplantModel>

      • Promise for the update, update data object, or undefined (no update needed).
    • Set item's active state.

      Parameters

      • active: any

        Active state

      • context: any

        Optional update context

      Returns Promise<Item<"base" | ModuleSubType>>

      • Update promise if item type supports the operation.
      • If item does not support the operation.
    • 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

    • Parameters

      • __namedParameters: {} = {}

      Returns null | string

    • Returns {
          actions: 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 }>,
          >;
          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 }>,
          >;
          artifact: 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>,
              >,
          >;
          attackNotes: ArrayField<
              HTMLField<
                  { initial: undefined; required: boolean },
                  AssignmentType<{ initial: undefined; required: boolean }>,
                  InitializedType<{ initial: undefined; required: boolean }>,
                  InitializedType<{ initial: undefined; required: boolean }>,
              >,
              { initial: undefined; required: false },
              AssignmentType<{ initial: undefined; required: boolean }>,
              InitializedType<{ initial: undefined; required: boolean }>,
              AssignmentType<
                  AssignmentType<{ initial: undefined; required: boolean }>,
                  { initial: undefined; required: false },
              >,
              InitializedType<
                  InitializedType<{ initial: undefined; required: boolean }>,
                  { initial: undefined; required: false },
              >,
              InitializedType<{ initial: undefined; required: boolean }>,
              PersistedType<
                  InitializedType<{ initial: undefined; required: boolean }>,
                  { initial: undefined; required: false },
              >,
          >;
          aura: SchemaField<
              {
                  custom: 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,
                          >,
                      >,
                  >;
                  school: StringField<
                      { initial: undefined; required: boolean },
                      AssignmentType<{ initial: undefined; required: boolean }>,
                      InitializedType<{ initial: undefined; required: boolean }>,
                      InitializedType<{ initial: undefined; required: boolean }>,
                  >;
              },
              { initial: undefined; required: boolean },
              AssignmentType<
                  {
                      custom: 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,
                              >,
                          >,
                      >;
                      school: StringField<
                          { initial: undefined; required: boolean },
                          AssignmentType<{ initial: undefined; required: boolean }>,
                          InitializedType<{ initial: undefined; required: boolean }>,
                          InitializedType<{ initial: undefined; required: boolean }>,
                      >;
                  },
                  SimpleMerge<{ initial: undefined; required: boolean }, DefaultOptions>,
              >,
              {
                  custom: InitializedType<
                      SimpleMerge<
                          { initial: undefined; required: boolean },
                          DefaultOptions,
                      >,
                  >;
                  school: InitializedType<{ initial: undefined; required: boolean }>;
              },
              {
                  custom: InitializedType<
                      SimpleMerge<
                          { initial: undefined; required: boolean },
                          DefaultOptions,
                      >,
                  >;
                  school: InitializedType<{ initial: undefined; required: boolean }>;
              },
          >;
          broken: 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>,
              >,
          >;
          carried: 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>,
              >,
          >;
          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 }>,
          >;
          cl: 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;
                  },
              >,
          >;
          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 }>,
          >;
          cursed: 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>,
              >,
          >;
          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 }>,
          >;
          effectNotes: ArrayField<
              HTMLField<
                  { initial: undefined; required: boolean },
                  AssignmentType<{ initial: undefined; required: boolean }>,
                  InitializedType<{ initial: undefined; required: boolean }>,
                  InitializedType<{ initial: undefined; required: boolean }>,
              >,
              { initial: undefined; required: false },
              AssignmentType<{ initial: undefined; required: boolean }>,
              InitializedType<{ initial: undefined; required: boolean }>,
              AssignmentType<
                  AssignmentType<{ initial: undefined; required: boolean }>,
                  { initial: undefined; required: false },
              >,
              InitializedType<
                  InitializedType<{ initial: undefined; required: boolean }>,
                  { initial: undefined; required: false },
              >,
              InitializedType<{ initial: undefined; required: boolean }>,
              PersistedType<
                  InitializedType<{ initial: undefined; required: boolean }>,
                  { initial: undefined; required: false },
              >,
          >;
          equipped: 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>,
              >,
          >;
          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 }>;
              },
          >;
          hardness: NumberField<
              { initial: undefined; integer: true; min: 0; required: boolean },
              AssignmentType<
                  { initial: undefined; integer: true; min: 0; required: boolean },
              >,
              InitializedType<
                  { initial: undefined; integer: true; min: 0; required: boolean },
              >,
              InitializedType<
                  { initial: undefined; integer: true; min: 0; required: boolean },
              >,
          >;
          hp: SchemaField<
              {
                  base: NumberField<
                      { initial: undefined; integer: true; min: 0; required: boolean },
                      AssignmentType<
                          { initial: undefined; integer: true; min: 0; required: boolean },
                      >,
                      InitializedType<
                          { initial: undefined; integer: true; min: 0; required: boolean },
                      >,
                      InitializedType<
                          { initial: undefined; integer: true; min: 0; required: boolean },
                      >,
                  >;
              },
              { initial: undefined; required: boolean },
              AssignmentType<
                  {
                      base: NumberField<
                          { initial: undefined; integer: true; min: 0; required: boolean },
                          AssignmentType<
                              { initial: undefined; integer: true; min: 0; required: boolean },
                          >,
                          InitializedType<
                              { initial: undefined; integer: true; min: 0; required: boolean },
                          >,
                          InitializedType<
                              { initial: undefined; integer: true; min: 0; required: boolean },
                          >,
                      >;
                  },
                  SimpleMerge<{ initial: undefined; required: boolean }, DefaultOptions>,
              >,
              {
                  base: InitializedType<
                      { initial: undefined; integer: true; min: 0; required: boolean },
                  >;
              },
              {
                  base: InitializedType<
                      { initial: undefined; integer: true; min: 0; required: boolean },
                  >;
              },
          >;
          identified: 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>,
              >,
          >;
          implant: NumberField<
              { initial: undefined; integer: true; min: 0; required: boolean },
              AssignmentType<
                  { initial: undefined; integer: true; min: 0; required: boolean },
              >,
              InitializedType<
                  { initial: undefined; integer: true; min: 0; required: boolean },
              >,
              InitializedType<
                  { initial: undefined; integer: true; min: 0; required: boolean },
              >,
          >;
          implanted: 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>,
              >,
          >;
          install: NumberField<
              { initial: undefined; integer: true; min: 0; required: boolean },
              AssignmentType<
                  { initial: undefined; integer: true; min: 0; required: boolean },
              >,
              InitializedType<
                  { initial: undefined; integer: true; min: 0; required: boolean },
              >,
              InitializedType<
                  { initial: undefined; integer: true; min: 0; required: boolean },
              >,
          >;
          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 }>,
          >;
          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 }>;
              },
          >;
          price: NumberField<
              { initial: undefined; min: 0; required: boolean },
              AssignmentType<{ initial: undefined; min: 0; required: boolean }>,
              InitializedType<{ initial: undefined; min: 0; required: boolean }>,
              InitializedType<{ initial: undefined; min: 0; required: boolean }>,
          >;
          quantity: NumberField<
              {
                  initial: undefined;
                  integer: true;
                  min: 0;
                  nullable: false;
                  required: false;
              },
              AssignmentType<
                  {
                      initial: undefined;
                      integer: true;
                      min: 0;
                      nullable: false;
                      required: false;
                  },
              >,
              InitializedType<
                  {
                      initial: undefined;
                      integer: true;
                      min: 0;
                      nullable: false;
                      required: false;
                  },
              >,
              InitializedType<
                  {
                      initial: undefined;
                      integer: true;
                      min: 0;
                      nullable: false;
                      required: false;
                  },
              >,
          >;
          resizing: 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>,
              >,
          >;
          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 }>,
          >;
          showInCombat: 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>,
              >,
          >;
          showInQuickbar: 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>,
              >,
          >;
          size: StringField<
              { blank: false; initial: undefined; required: boolean },
              AssignmentType<{ blank: false; initial: undefined; required: boolean }>,
              InitializedType<{ blank: false; initial: undefined; required: boolean }>,
              InitializedType<{ blank: false; initial: undefined; required: boolean }>,
          >;
          slot: StringField<
              { initial: undefined; required: boolean },
              AssignmentType<{ initial: undefined; required: boolean }>,
              InitializedType<{ initial: undefined; required: boolean }>,
              InitializedType<{ initial: undefined; required: boolean }>,
          >;
          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 }>,
          >;
          timeworn: 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>,
              >,
          >;
          unidentified: SchemaField<
              {
                  name: StringField<
                      { initial: undefined; required: boolean },
                      AssignmentType<{ initial: undefined; required: boolean }>,
                      InitializedType<{ initial: undefined; required: boolean }>,
                      InitializedType<{ initial: undefined; required: boolean }>,
                  >;
                  price: NumberField<
                      { initial: undefined; min: 0; required: boolean },
                      AssignmentType<{ initial: undefined; min: 0; required: boolean }>,
                      InitializedType<{ initial: undefined; min: 0; required: boolean }>,
                      InitializedType<{ initial: undefined; min: 0; required: boolean }>,
                  >;
              },
              { initial: undefined; required: boolean },
              AssignmentType<
                  {
                      name: StringField<
                          { initial: undefined; required: boolean },
                          AssignmentType<{ initial: undefined; required: boolean }>,
                          InitializedType<{ initial: undefined; required: boolean }>,
                          InitializedType<{ initial: undefined; required: boolean }>,
                      >;
                      price: NumberField<
                          { initial: undefined; min: 0; required: boolean },
                          AssignmentType<{ initial: undefined; min: 0; required: boolean }>,
                          InitializedType<{ initial: undefined; min: 0; required: boolean }>,
                          InitializedType<{ initial: undefined; min: 0; required: boolean }>,
                      >;
                  },
                  SimpleMerge<{ initial: undefined; required: boolean }, DefaultOptions>,
              >,
              {
                  name: InitializedType<{ initial: undefined; required: boolean }>;
                  price: InitializedType<{ initial: undefined; min: 0; required: boolean }>;
              },
              {
                  name: InitializedType<{ initial: undefined; required: boolean }>;
                  price: InitializedType<{ initial: undefined; min: 0; required: boolean }>;
              },
          >;
          uses: SchemaField<
              {
                  cost: FormulaField;
                  maxFormula: FormulaField;
                  per: StringField<
                      { required: false },
                      AssignmentType<{ required: false }>,
                      InitializedType<{ required: false }>,
                      InitializedType<{ required: false }>,
                  >;
                  rechargeFormula: FormulaField;
                  source: StringField<
                      { required: false },
                      AssignmentType<{ required: false }>,
                      InitializedType<{ required: false }>,
                      InitializedType<{ required: false }>,
                  >;
                  value: NumberField<
                      { initial: undefined; integer: true; min: 0; required: false },
                      AssignmentType<
                          { initial: undefined; integer: true; min: 0; required: false },
                      >,
                      InitializedType<
                          { initial: undefined; integer: true; min: 0; required: false },
                      >,
                      InitializedType<
                          { initial: undefined; integer: true; min: 0; required: false },
                      >,
                  >;
              },
              { initial: undefined; required: false },
              AssignmentType<
                  {
                      cost: FormulaField;
                      maxFormula: FormulaField;
                      per: StringField<
                          { required: false },
                          AssignmentType<{ required: false }>,
                          InitializedType<{ required: false }>,
                          InitializedType<{ required: false }>,
                      >;
                      rechargeFormula: FormulaField;
                      source: StringField<
                          { required: false },
                          AssignmentType<{ required: false }>,
                          InitializedType<{ required: false }>,
                          InitializedType<{ required: false }>,
                      >;
                      value: NumberField<
                          { initial: undefined; integer: true; min: 0; required: false },
                          AssignmentType<
                              { initial: undefined; integer: true; min: 0; required: false },
                          >,
                          InitializedType<
                              { initial: undefined; integer: true; min: 0; required: false },
                          >,
                          InitializedType<
                              { initial: undefined; integer: true; min: 0; required: false },
                          >,
                      >;
                  },
                  SimpleMerge<{ initial: undefined; required: false }, DefaultOptions>,
              >,
              {
                  cost: InitializedType<DefaultOptions>;
                  maxFormula: InitializedType<DefaultOptions>;
                  per: InitializedType<{ required: false }>;
                  rechargeFormula: InitializedType<DefaultOptions>;
                  source: InitializedType<{ required: false }>;
                  value: InitializedType<
                      { initial: undefined; integer: true; min: 0; required: false },
                  >;
              },
              {
                  cost: InitializedType<DefaultOptions>;
                  maxFormula: InitializedType<DefaultOptions>;
                  per: InitializedType<{ required: false }>;
                  rechargeFormula: InitializedType<DefaultOptions>;
                  source: InitializedType<{ required: false }>;
                  value: InitializedType<
                      { initial: undefined; integer: true; min: 0; required: false },
                  >;
              },
          >;
          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 }>,
          >;
          weight: SchemaField<
              {
                  value: NumberField<
                      { min: 0 },
                      AssignmentType<{ min: 0 }>,
                      InitializedType<{ min: 0 }>,
                      InitializedType<{ min: 0 }>,
                  >;
              },
              { initial: undefined; required: boolean },
              AssignmentType<
                  {
                      value: NumberField<
                          { min: 0 },
                          AssignmentType<{ min: 0 }>,
                          InitializedType<{ min: 0 }>,
                          InitializedType<{ min: 0 }>,
                      >;
                  },
                  SimpleMerge<{ initial: undefined; required: boolean }, DefaultOptions>,
              >,
              { value: InitializedType<{ min: 0 }> },
              { value: InitializedType<{ min: 0 }> },
          >;
      }

    • 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