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

    Class AmmoModel

    Basic Item model with actions and related data

    Hierarchy (View Summary)

    Index

    Constructors

    Properties

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

    false

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

    true

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

    Caster Level

    null

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

    false

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

    true

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

    true

    languages?: Set<string>
    links?: { children?: LinkModel[]; supplements?: LinkModel[] }
    masterwork?: boolean
    maxFormula?: string
    misfire?: number
    nonhumanoid: boolean
    parent?: ItemPF
    per?: string
    price?: number
    quantity: number
    rechargeFormula?: string
    recoverChance?: 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"
    source?: string
    subType:
        | "arrow"
        | "bolt"
        | "repeatingBolt"
        | "slingBullet"
        | "gunBullet"
        | "dragoonBullet"
        | "dart"
        | "siege"
    tag?: string
    timeworn: boolean

    false

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

    Accessors

    • get activeState(): undefined | boolean

      Active state as per what setActive would correspond with.

      Returns undefined | 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(): string

      The default spell school of this items aura, if any

      Returns string

    • get effectiveCl(): number

      Effective caster level of this item.

      Returns number

    • get hasFiniteCharges(): boolean

      Finite charges

      Returns boolean

    • get isActive(): undefined | 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 undefined | 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: object

        Creation data

      • context: object

        Context

      • userId: string

        Triggering user ID

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

      • 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

    • Returns {
          abundant: 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>,
              >,
          >;
          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 }>,
          >;
          alignments: TypeDataField<
              SystemConstructor,
              { initial: undefined; required: false },
              any,
              any,
              any,
          >;
          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 },
              >,
          >;
          enh: 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;
                  },
              >,
          >;
          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>,
              >,
          >;
          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 }>;
              },
          >;
          masterwork: 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>,
              >,
          >;
          material: SchemaField<
              {
                  base: SchemaField<
                      {
                          custom: BooleanField<
                              { initial: undefined; required: false },
                              AssignmentType<
                                  SimpleMerge<
                                      { initial: undefined; required: false },
                                      DefaultOptions,
                                  >,
                              >,
                              InitializedType<
                                  SimpleMerge<
                                      { initial: undefined; required: false },
                                      DefaultOptions,
                                  >,
                              >,
                              InitializedType<
                                  SimpleMerge<
                                      { initial: undefined; required: false },
                                      DefaultOptions,
                                  >,
                              >,
                          >;
                          value: StringField<
                              { initial: undefined; required: false },
                              AssignmentType<{ initial: undefined; required: false }>,
                              InitializedType<{ initial: undefined; required: false }>,
                              InitializedType<{ initial: undefined; required: false }>,
                          >;
                      },
                      { initial: undefined; required: boolean },
                      AssignmentType<
                          {
                              custom: BooleanField<
                                  { initial: undefined; required: false },
                                  AssignmentType<
                                      SimpleMerge<
                                          { initial: undefined; required: false },
                                          DefaultOptions,
                                      >,
                                  >,
                                  InitializedType<
                                      SimpleMerge<
                                          { initial: undefined; required: false },
                                          DefaultOptions,
                                      >,
                                  >,
                                  InitializedType<
                                      SimpleMerge<
                                          { initial: undefined; required: false },
                                          DefaultOptions,
                                      >,
                                  >,
                              >;
                              value: StringField<
                                  { initial: undefined; required: false },
                                  AssignmentType<{ initial: undefined; required: false }>,
                                  InitializedType<{ initial: undefined; required: false }>,
                                  InitializedType<{ initial: undefined; required: false }>,
                              >;
                          },
                          SimpleMerge<{ initial: undefined; required: boolean }, DefaultOptions>,
                      >,
                      {
                          custom: InitializedType<
                              SimpleMerge<
                                  { initial: undefined; required: false },
                                  DefaultOptions,
                              >,
                          >;
                          value: InitializedType<{ initial: undefined; required: false }>;
                      },
                      {
                          custom: InitializedType<
                              SimpleMerge<
                                  { initial: undefined; required: false },
                                  DefaultOptions,
                              >,
                          >;
                          value: InitializedType<{ initial: undefined; required: false }>;
                      },
                  >;
                  normal: SchemaField<
                      {
                          custom: BooleanField<
                              { initial: undefined; required: false },
                              AssignmentType<
                                  SimpleMerge<
                                      { initial: undefined; required: false },
                                      DefaultOptions,
                                  >,
                              >,
                              InitializedType<
                                  SimpleMerge<
                                      { initial: undefined; required: false },
                                      DefaultOptions,
                                  >,
                              >,
                              InitializedType<
                                  SimpleMerge<
                                      { initial: undefined; required: false },
                                      DefaultOptions,
                                  >,
                              >,
                          >;
                          value: StringField<
                              { initial: undefined; required: false },
                              AssignmentType<{ initial: undefined; required: false }>,
                              InitializedType<{ initial: undefined; required: false }>,
                              InitializedType<{ initial: undefined; required: false }>,
                          >;
                      },
                      { initial: undefined; required: boolean },
                      AssignmentType<
                          {
                              custom: BooleanField<
                                  { initial: undefined; required: false },
                                  AssignmentType<
                                      SimpleMerge<
                                          { initial: undefined; required: false },
                                          DefaultOptions,
                                      >,
                                  >,
                                  InitializedType<
                                      SimpleMerge<
                                          { initial: undefined; required: false },
                                          DefaultOptions,
                                      >,
                                  >,
                                  InitializedType<
                                      SimpleMerge<
                                          { initial: undefined; required: false },
                                          DefaultOptions,
                                      >,
                                  >,
                              >;
                              value: StringField<
                                  { initial: undefined; required: false },
                                  AssignmentType<{ initial: undefined; required: false }>,
                                  InitializedType<{ initial: undefined; required: false }>,
                                  InitializedType<{ initial: undefined; required: false }>,
                              >;
                          },
                          SimpleMerge<{ initial: undefined; required: boolean }, DefaultOptions>,
                      >,
                      {
                          custom: InitializedType<
                              SimpleMerge<
                                  { initial: undefined; required: false },
                                  DefaultOptions,
                              >,
                          >;
                          value: InitializedType<{ initial: undefined; required: false }>;
                      },
                      {
                          custom: InitializedType<
                              SimpleMerge<
                                  { initial: undefined; required: false },
                                  DefaultOptions,
                              >,
                          >;
                          value: InitializedType<{ initial: undefined; required: false }>;
                      },
                  >;
              },
              { initial: undefined; required: false },
              AssignmentType<
                  {
                      base: SchemaField<
                          {
                              custom: BooleanField<
                                  { initial: undefined; required: false },
                                  AssignmentType<
                                      SimpleMerge<
                                          { initial: undefined; required: false },
                                          DefaultOptions,
                                      >,
                                  >,
                                  InitializedType<
                                      SimpleMerge<
                                          { initial: undefined; required: false },
                                          DefaultOptions,
                                      >,
                                  >,
                                  InitializedType<
                                      SimpleMerge<
                                          { initial: undefined; required: false },
                                          DefaultOptions,
                                      >,
                                  >,
                              >;
                              value: StringField<
                                  { initial: undefined; required: false },
                                  AssignmentType<{ initial: undefined; required: false }>,
                                  InitializedType<{ initial: undefined; required: false }>,
                                  InitializedType<{ initial: undefined; required: false }>,
                              >;
                          },
                          { initial: undefined; required: boolean },
                          AssignmentType<
                              {
                                  custom: BooleanField<
                                      { initial: undefined; required: false },
                                      AssignmentType<
                                          SimpleMerge<{ initial: ...; required: ... }, DefaultOptions>,
                                      >,
                                      InitializedType<
                                          SimpleMerge<{ initial: ...; required: ... }, DefaultOptions>,
                                      >,
                                      InitializedType<
                                          SimpleMerge<{ initial: ...; required: ... }, DefaultOptions>,
                                      >,
                                  >;
                                  value: StringField<
                                      { initial: undefined; required: false },
                                      AssignmentType<{ initial: undefined; required: false }>,
                                      InitializedType<{ initial: undefined; required: false }>,
                                      InitializedType<{ initial: undefined; required: false }>,
                                  >;
                              },
                              SimpleMerge<{ initial: undefined; required: boolean }, DefaultOptions>,
                          >,
                          {
                              custom: InitializedType<
                                  SimpleMerge<
                                      { initial: undefined; required: false },
                                      DefaultOptions,
                                  >,
                              >;
                              value: InitializedType<{ initial: undefined; required: false }>;
                          },
                          {
                              custom: InitializedType<
                                  SimpleMerge<
                                      { initial: undefined; required: false },
                                      DefaultOptions,
                                  >,
                              >;
                              value: InitializedType<{ initial: undefined; required: false }>;
                          },
                      >;
                      normal: SchemaField<
                          {
                              custom: BooleanField<
                                  { initial: undefined; required: false },
                                  AssignmentType<
                                      SimpleMerge<
                                          { initial: undefined; required: false },
                                          DefaultOptions,
                                      >,
                                  >,
                                  InitializedType<
                                      SimpleMerge<
                                          { initial: undefined; required: false },
                                          DefaultOptions,
                                      >,
                                  >,
                                  InitializedType<
                                      SimpleMerge<
                                          { initial: undefined; required: false },
                                          DefaultOptions,
                                      >,
                                  >,
                              >;
                              value: StringField<
                                  { initial: undefined; required: false },
                                  AssignmentType<{ initial: undefined; required: false }>,
                                  InitializedType<{ initial: undefined; required: false }>,
                                  InitializedType<{ initial: undefined; required: false }>,
                              >;
                          },
                          { initial: undefined; required: boolean },
                          AssignmentType<
                              {
                                  custom: BooleanField<
                                      { initial: undefined; required: false },
                                      AssignmentType<
                                          SimpleMerge<{ initial: ...; required: ... }, DefaultOptions>,
                                      >,
                                      InitializedType<
                                          SimpleMerge<{ initial: ...; required: ... }, DefaultOptions>,
                                      >,
                                      InitializedType<
                                          SimpleMerge<{ initial: ...; required: ... }, DefaultOptions>,
                                      >,
                                  >;
                                  value: StringField<
                                      { initial: undefined; required: false },
                                      AssignmentType<{ initial: undefined; required: false }>,
                                      InitializedType<{ initial: undefined; required: false }>,
                                      InitializedType<{ initial: undefined; required: false }>,
                                  >;
                              },
                              SimpleMerge<{ initial: undefined; required: boolean }, DefaultOptions>,
                          >,
                          {
                              custom: InitializedType<
                                  SimpleMerge<
                                      { initial: undefined; required: false },
                                      DefaultOptions,
                                  >,
                              >;
                              value: InitializedType<{ initial: undefined; required: false }>;
                          },
                          {
                              custom: InitializedType<
                                  SimpleMerge<
                                      { initial: undefined; required: false },
                                      DefaultOptions,
                                  >,
                              >;
                              value: InitializedType<{ initial: undefined; required: false }>;
                          },
                      >;
                  },
                  SimpleMerge<{ initial: undefined; required: false }, DefaultOptions>,
              >,
              {
                  base: {
                      custom: InitializedType<
                          SimpleMerge<{ initial: undefined; required: false }, DefaultOptions>,
                      >;
                      value: InitializedType<{ initial: undefined; required: false }>;
                  };
                  normal: {
                      custom: InitializedType<
                          SimpleMerge<{ initial: undefined; required: false }, DefaultOptions>,
                      >;
                      value: InitializedType<{ initial: undefined; required: false }>;
                  };
              },
              {
                  base: {
                      custom: InitializedType<
                          SimpleMerge<{ initial: undefined; required: false }, DefaultOptions>,
                      >;
                      value: InitializedType<{ initial: undefined; required: false }>;
                  };
                  normal: {
                      custom: InitializedType<
                          SimpleMerge<{ initial: undefined; required: false }, DefaultOptions>,
                      >;
                      value: InitializedType<{ initial: undefined; 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;
                  },
              >,
          >;
          recoverChance: NumberField<
              {
                  initial: undefined;
                  max: 100;
                  min: 0;
                  nullable: true;
                  required: boolean;
              },
              AssignmentType<
                  {
                      initial: undefined;
                      max: 100;
                      min: 0;
                      nullable: true;
                      required: boolean;
                  },
              >,
              InitializedType<
                  {
                      initial: undefined;
                      max: 100;
                      min: 0;
                      nullable: true;
                      required: boolean;
                  },
              >,
              InitializedType<
                  {
                      initial: undefined;
                      max: 100;
                      min: 0;
                      nullable: true;
                      required: boolean;
                  },
              >,
          >;
          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 }>,
          >;
          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 }>;
              },
          >;
          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