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

    Class HauntModel

    Haunt actor data model

    Hierarchy

    • TypeDataModel
      • HauntModel
    Index

    Constructors

    constructor

    Methods

    defineSchema migrateData

    Constructors

    • Parameters

      • ...args: ConstructorArgs<any, any>

      Returns HauntModel

    Methods

    • Define the data schema for documents of this type. The schema is populated the first time it is accessed and cached for future reuse.

      Returns {
          attributes: SchemaField<
              {
                  hp: SchemaField<
                      {
                          base: NumberField<
                              { initial: 0; integer: true; nullable: false },
                              AssignmentType<{ initial: 0; integer: true; nullable: false }>,
                              InitializedType<{ initial: 0; integer: true; nullable: false }>,
                              InitializedType<{ initial: 0; integer: true; nullable: false }>,
                          >;
                          offset: NumberField<
                              { initial: 0; integer: true; nullable: false },
                              AssignmentType<{ initial: 0; integer: true; nullable: false }>,
                              InitializedType<{ initial: 0; integer: true; nullable: false }>,
                              InitializedType<{ initial: 0; integer: true; nullable: false }>,
                          >;
                      },
                      DefaultOptions,
                      AssignmentType<
                          {
                              base: NumberField<
                                  { initial: 0; integer: true; nullable: false },
                                  AssignmentType<{ initial: 0; integer: true; nullable: false }>,
                                  InitializedType<{ initial: 0; integer: true; nullable: false }>,
                                  InitializedType<{ initial: 0; integer: true; nullable: false }>,
                              >;
                              offset: NumberField<
                                  { initial: 0; integer: true; nullable: false },
                                  AssignmentType<{ initial: 0; integer: true; nullable: false }>,
                                  InitializedType<{ initial: 0; integer: true; nullable: false }>,
                                  InitializedType<{ initial: 0; integer: true; nullable: false }>,
                              >;
                          },
                          SimpleMerge<DefaultOptions, DefaultOptions>,
                      >,
                      {
                          base: InitializedType<
                              { initial: 0; integer: true; nullable: false },
                          >;
                          offset: InitializedType<{ initial: 0; integer: true; nullable: false }>;
                      },
                      {
                          base: InitializedType<
                              { initial: 0; integer: true; nullable: false },
                          >;
                          offset: InitializedType<{ initial: 0; integer: true; nullable: false }>;
                      },
                  >;
                  init: SchemaField<
                      {
                          value: NumberField<
                              { initial: 10; integer: true; nullable: false },
                              AssignmentType<{ initial: 10; integer: true; nullable: false }>,
                              InitializedType<{ initial: 10; integer: true; nullable: false }>,
                              InitializedType<{ initial: 10; integer: true; nullable: false }>,
                          >;
                      },
                      DefaultOptions,
                      AssignmentType<
                          {
                              value: NumberField<
                                  { initial: 10; integer: true; nullable: false },
                                  AssignmentType<{ initial: 10; integer: true; nullable: false }>,
                                  InitializedType<{ initial: 10; integer: true; nullable: false }>,
                                  InitializedType<{ initial: 10; integer: true; nullable: false }>,
                              >;
                          },
                          SimpleMerge<DefaultOptions, DefaultOptions>,
                      >,
                      {
                          value: InitializedType<
                              { initial: 10; integer: true; nullable: false },
                          >;
                      },
                      {
                          value: InitializedType<
                              { initial: 10; integer: true; nullable: false },
                          >;
                      },
                  >;
              },
              DefaultOptions,
              AssignmentType<
                  {
                      hp: SchemaField<
                          {
                              base: NumberField<
                                  { initial: 0; integer: true; nullable: false },
                                  AssignmentType<{ initial: 0; integer: true; nullable: false }>,
                                  InitializedType<{ initial: 0; integer: true; nullable: false }>,
                                  InitializedType<{ initial: 0; integer: true; nullable: false }>,
                              >;
                              offset: NumberField<
                                  { initial: 0; integer: true; nullable: false },
                                  AssignmentType<{ initial: 0; integer: true; nullable: false }>,
                                  InitializedType<{ initial: 0; integer: true; nullable: false }>,
                                  InitializedType<{ initial: 0; integer: true; nullable: false }>,
                              >;
                          },
                          DefaultOptions,
                          AssignmentType<
                              {
                                  base: NumberField<
                                      { initial: 0; integer: true; nullable: false },
                                      AssignmentType<{ initial: 0; integer: true; nullable: false }>,
                                      InitializedType<{ initial: 0; integer: true; nullable: false }>,
                                      InitializedType<{ initial: 0; integer: true; nullable: false }>,
                                  >;
                                  offset: NumberField<
                                      { initial: 0; integer: true; nullable: false },
                                      AssignmentType<{ initial: 0; integer: true; nullable: false }>,
                                      InitializedType<{ initial: 0; integer: true; nullable: false }>,
                                      InitializedType<{ initial: 0; integer: true; nullable: false }>,
                                  >;
                              },
                              SimpleMerge<DefaultOptions, DefaultOptions>,
                          >,
                          {
                              base: InitializedType<
                                  { initial: 0; integer: true; nullable: false },
                              >;
                              offset: InitializedType<
                                  { initial: 0; integer: true; nullable: false },
                              >;
                          },
                          {
                              base: InitializedType<
                                  { initial: 0; integer: true; nullable: false },
                              >;
                              offset: InitializedType<
                                  { initial: 0; integer: true; nullable: false },
                              >;
                          },
                      >;
                      init: SchemaField<
                          {
                              value: NumberField<
                                  { initial: 10; integer: true; nullable: false },
                                  AssignmentType<{ initial: 10; integer: true; nullable: false }>,
                                  InitializedType<{ initial: 10; integer: true; nullable: false }>,
                                  InitializedType<{ initial: 10; integer: true; nullable: false }>,
                              >;
                          },
                          DefaultOptions,
                          AssignmentType<
                              {
                                  value: NumberField<
                                      { initial: 10; integer: true; nullable: false },
                                      AssignmentType<{ initial: 10; integer: true; nullable: false }>,
                                      InitializedType<{ initial: 10; integer: true; nullable: false }>,
                                      InitializedType<{ initial: 10; integer: true; nullable: false }>,
                                  >;
                              },
                              SimpleMerge<DefaultOptions, DefaultOptions>,
                          >,
                          {
                              value: InitializedType<
                                  { initial: 10; integer: true; nullable: false },
                              >;
                          },
                          {
                              value: InitializedType<
                                  { initial: 10; integer: true; nullable: false },
                              >;
                          },
                      >;
                  },
                  SimpleMerge<DefaultOptions, DefaultOptions>,
              >,
              {
                  hp: {
                      base: InitializedType<{ initial: 0; integer: true; nullable: false }>;
                      offset: InitializedType<{ initial: 0; integer: true; nullable: false }>;
                  };
                  init: {
                      value: InitializedType<
                          { initial: 10; integer: true; nullable: false },
                      >;
                  };
              },
              {
                  hp: {
                      base: InitializedType<{ initial: 0; integer: true; nullable: false }>;
                      offset: InitializedType<{ initial: 0; integer: true; nullable: false }>;
                  };
                  init: {
                      value: InitializedType<
                          { initial: 10; integer: true; nullable: false },
                      >;
                  };
              },
          >;
          details: SchemaField<
              {
                  alignment: StringField<
                      {
                          choices: () => {
                              ce: "Chaotic Evil";
                              cg: "Chaotic Good";
                              cn: "Chaotic Neutral";
                              le: "Lawful Evil";
                              lg: "Lawful Good";
                              ln: "Lawful Neutral";
                              ne: "Neutral Evil";
                              ng: "Neutral Good";
                              tn: "Neutral";
                          };
                          initial: "tn";
                          required: true;
                      },
                      AssignmentType<
                          {
                              choices: () => {
                                  ce: "Chaotic Evil";
                                  cg: "Chaotic Good";
                                  cn: "Chaotic Neutral";
                                  le: "Lawful Evil";
                                  lg: "Lawful Good";
                                  ln: "Lawful Neutral";
                                  ne: "Neutral Evil";
                                  ng: "Neutral Good";
                                  tn: "Neutral";
                              };
                              initial: "tn";
                              required: true;
                          },
                      >,
                      InitializedType<
                          {
                              choices: () => {
                                  ce: "Chaotic Evil";
                                  cg: "Chaotic Good";
                                  cn: "Chaotic Neutral";
                                  le: "Lawful Evil";
                                  lg: "Lawful Good";
                                  ln: "Lawful Neutral";
                                  ne: "Neutral Evil";
                                  ng: "Neutral Good";
                                  tn: "Neutral";
                              };
                              initial: "tn";
                              required: true;
                          },
                      >,
                      InitializedType<
                          {
                              choices: () => {
                                  ce: "Chaotic Evil";
                                  cg: "Chaotic Good";
                                  cn: "Chaotic Neutral";
                                  le: "Lawful Evil";
                                  lg: "Lawful Good";
                                  ln: "Lawful Neutral";
                                  ne: "Neutral Evil";
                                  ng: "Neutral Good";
                                  tn: "Neutral";
                              };
                              initial: "tn";
                              required: true;
                          },
                      >,
                  >;
                  area: SchemaField<
                      {
                          size: NumberField<
                              { initial: 0; integer: true; min: 0; nullable: false },
                              AssignmentType<{ initial: 0; integer: true; min: 0; nullable: false }>,
                              InitializedType<
                                  { initial: 0; integer: true; min: 0; nullable: false },
                              >,
                              InitializedType<
                                  { initial: 0; integer: true; min: 0; nullable: false },
                              >,
                          >;
                          type: StringField<
                              {
                                  choices: () => Record<string, string>;
                                  initial: "circle";
                                  required: true;
                              },
                              AssignmentType<
                                  {
                                      choices: () => Record<string, string>;
                                      initial: "circle";
                                      required: true;
                                  },
                              >,
                              string,
                              string,
                          >;
                      },
                      DefaultOptions,
                      AssignmentType<
                          {
                              size: NumberField<
                                  { initial: 0; integer: true; min: 0; nullable: false },
                                  AssignmentType<
                                      { initial: 0; integer: true; min: 0; nullable: false },
                                  >,
                                  InitializedType<
                                      { initial: 0; integer: true; min: 0; nullable: false },
                                  >,
                                  InitializedType<
                                      { initial: 0; integer: true; min: 0; nullable: false },
                                  >,
                              >;
                              type: StringField<
                                  {
                                      choices: () => Record<string, string>;
                                      initial: "circle";
                                      required: true;
                                  },
                                  AssignmentType<
                                      {
                                          choices: () => Record<(...), (...)>;
                                          initial: "circle";
                                          required: true;
                                      },
                                  >,
                                  string,
                                  string,
                              >;
                          },
                          SimpleMerge<DefaultOptions, DefaultOptions>,
                      >,
                      {
                          size: InitializedType<
                              { initial: 0; integer: true; min: 0; nullable: false },
                          >;
                          type: string;
                      },
                      {
                          size: InitializedType<
                              { initial: 0; integer: true; min: 0; nullable: false },
                          >;
                          type: string;
                      },
                  >;
                  aura: SchemaField<
                      {
                          custom: BooleanField<
                              { initial: false },
                              AssignmentType<SimpleMerge<{ initial: false }, DefaultOptions>>,
                              InitializedType<SimpleMerge<{ initial: false }, DefaultOptions>>,
                              InitializedType<SimpleMerge<{ initial: false }, DefaultOptions>>,
                          >;
                          school: StringField<
                              DefaultOptions,
                              AssignmentType<DefaultOptions>,
                              InitializedType<DefaultOptions>,
                              InitializedType<DefaultOptions>,
                          >;
                      },
                      DefaultOptions,
                      AssignmentType<
                          {
                              custom: BooleanField<
                                  { initial: false },
                                  AssignmentType<SimpleMerge<{ initial: false }, DefaultOptions>>,
                                  InitializedType<SimpleMerge<{ initial: false }, DefaultOptions>>,
                                  InitializedType<SimpleMerge<{ initial: false }, DefaultOptions>>,
                              >;
                              school: StringField<
                                  DefaultOptions,
                                  AssignmentType<DefaultOptions>,
                                  InitializedType<DefaultOptions>,
                                  InitializedType<DefaultOptions>,
                              >;
                          },
                          SimpleMerge<DefaultOptions, DefaultOptions>,
                      >,
                      {
                          custom: InitializedType<
                              SimpleMerge<{ initial: false }, DefaultOptions>,
                          >;
                          school: InitializedType<DefaultOptions>;
                      },
                      {
                          custom: InitializedType<
                              SimpleMerge<{ initial: false }, DefaultOptions>,
                          >;
                          school: InitializedType<DefaultOptions>;
                      },
                  >;
                  cl: NumberField<
                      { initial: 1; integer: true; min: 1; nullable: false },
                      AssignmentType<{ initial: 1; integer: true; min: 1; nullable: false }>,
                      InitializedType<{ initial: 1; integer: true; min: 1; nullable: false }>,
                      InitializedType<{ initial: 1; integer: true; min: 1; nullable: false }>,
                  >;
                  cr: SchemaField<
                      {
                          offset: NumberField<
                              { initial: 0; integer: true; min: 0; nullable: false },
                              AssignmentType<{ initial: 0; integer: true; min: 0; nullable: false }>,
                              InitializedType<
                                  { initial: 0; integer: true; min: 0; nullable: false },
                              >,
                              InitializedType<
                                  { initial: 0; integer: true; min: 0; nullable: false },
                              >,
                          >;
                      },
                      DefaultOptions,
                      AssignmentType<
                          {
                              offset: NumberField<
                                  { initial: 0; integer: true; min: 0; nullable: false },
                                  AssignmentType<
                                      { initial: 0; integer: true; min: 0; nullable: false },
                                  >,
                                  InitializedType<
                                      { initial: 0; integer: true; min: 0; nullable: false },
                                  >,
                                  InitializedType<
                                      { initial: 0; integer: true; min: 0; nullable: false },
                                  >,
                              >;
                          },
                          SimpleMerge<DefaultOptions, DefaultOptions>,
                      >,
                      {
                          offset: InitializedType<
                              { initial: 0; integer: true; min: 0; nullable: false },
                          >;
                      },
                      {
                          offset: InitializedType<
                              { initial: 0; integer: true; min: 0; nullable: false },
                          >;
                      },
                  >;
                  destruction: HTMLField<
                      DefaultOptions,
                      AssignmentType<DefaultOptions>,
                      string,
                      string,
                  >;
                  effect: HTMLField<
                      DefaultOptions,
                      AssignmentType<DefaultOptions>,
                      string,
                      string,
                  >;
                  notes: HTMLField<
                      DefaultOptions,
                      AssignmentType<DefaultOptions>,
                      string,
                      string,
                  >;
                  notice: SchemaField<
                      {
                          dc: NumberField<
                              { initial: 0; integer: true; min: 0; nullable: false },
                              AssignmentType<{ initial: 0; integer: true; min: 0; nullable: false }>,
                              InitializedType<
                                  { initial: 0; integer: true; min: 0; nullable: false },
                              >,
                              InitializedType<
                                  { initial: 0; integer: true; min: 0; nullable: false },
                              >,
                          >;
                          desc: StringField<
                              DefaultOptions,
                              AssignmentType<DefaultOptions>,
                              InitializedType<DefaultOptions>,
                              InitializedType<DefaultOptions>,
                          >;
                          value: StringField<
                              DefaultOptions,
                              AssignmentType<DefaultOptions>,
                              InitializedType<DefaultOptions>,
                              InitializedType<DefaultOptions>,
                          >;
                      },
                      DefaultOptions,
                      AssignmentType<
                          {
                              dc: NumberField<
                                  { initial: 0; integer: true; min: 0; nullable: false },
                                  AssignmentType<
                                      { initial: 0; integer: true; min: 0; nullable: false },
                                  >,
                                  InitializedType<
                                      { initial: 0; integer: true; min: 0; nullable: false },
                                  >,
                                  InitializedType<
                                      { initial: 0; integer: true; min: 0; nullable: false },
                                  >,
                              >;
                              desc: StringField<
                                  DefaultOptions,
                                  AssignmentType<DefaultOptions>,
                                  InitializedType<DefaultOptions>,
                                  InitializedType<DefaultOptions>,
                              >;
                              value: StringField<
                                  DefaultOptions,
                                  AssignmentType<DefaultOptions>,
                                  InitializedType<DefaultOptions>,
                                  InitializedType<DefaultOptions>,
                              >;
                          },
                          SimpleMerge<DefaultOptions, DefaultOptions>,
                      >,
                      {
                          dc: InitializedType<
                              { initial: 0; integer: true; min: 0; nullable: false },
                          >;
                          desc: InitializedType<DefaultOptions>;
                          value: InitializedType<DefaultOptions>;
                      },
                      {
                          dc: InitializedType<
                              { initial: 0; integer: true; min: 0; nullable: false },
                          >;
                          desc: InitializedType<DefaultOptions>;
                          value: InitializedType<DefaultOptions>;
                      },
                  >;
                  reset: SchemaField<
                      {
                          units: StringField<
                              {
                                  blank: true;
                                  choices: () => {
                                      day: "Days";
                                      hour: "Hours";
                                      inst: "Instantaneous";
                                      minute: "Minutes";
                                      month: "Months";
                                      perm: "Permanent";
                                      round: "Rounds";
                                      seeText: "See Text";
                                      spec: "Special";
                                      turn: "Turn";
                                      year: "Years";
                                  };
                              },
                              AssignmentType<
                                  {
                                      blank: true;
                                      choices: () => {
                                          day: "Days";
                                          hour: "Hours";
                                          inst: "Instantaneous";
                                          minute: "Minutes";
                                          month: "Months";
                                          perm: "Permanent";
                                          round: "Rounds";
                                          seeText: "See Text";
                                          spec: "Special";
                                          turn: "Turn";
                                          year: "Years";
                                      };
                                  },
                              >,
                              InitializedType<
                                  {
                                      blank: true;
                                      choices: () => {
                                          day: "Days";
                                          hour: "Hours";
                                          inst: "Instantaneous";
                                          minute: "Minutes";
                                          month: "Months";
                                          perm: "Permanent";
                                          round: "Rounds";
                                          seeText: "See Text";
                                          spec: "Special";
                                          turn: "Turn";
                                          year: "Years";
                                      };
                                  },
                              >,
                              InitializedType<
                                  {
                                      blank: true;
                                      choices: () => {
                                          day: "Days";
                                          hour: "Hours";
                                          inst: "Instantaneous";
                                          minute: "Minutes";
                                          month: "Months";
                                          perm: "Permanent";
                                          round: "Rounds";
                                          seeText: "See Text";
                                          spec: "Special";
                                          turn: "Turn";
                                          year: "Years";
                                      };
                                  },
                              >,
                          >;
                          value: StringField<
                              DefaultOptions,
                              AssignmentType<DefaultOptions>,
                              InitializedType<DefaultOptions>,
                              InitializedType<DefaultOptions>,
                          >;
                      },
                      DefaultOptions,
                      AssignmentType<
                          {
                              units: StringField<
                                  {
                                      blank: true;
                                      choices: () => {
                                          day: "Days";
                                          hour: "Hours";
                                          inst: "Instantaneous";
                                          minute: "Minutes";
                                          month: "Months";
                                          perm: "Permanent";
                                          round: "Rounds";
                                          seeText: "See Text";
                                          spec: "Special";
                                          turn: "Turn";
                                          year: "Years";
                                      };
                                  },
                                  AssignmentType<
                                      {
                                          blank: true;
                                          choices: () => {
                                              day: ...;
                                              hour: ...;
                                              inst: ...;
                                              minute: ...;
                                              month: ...;
                                              perm: ...;
                                              round: ...;
                                              seeText: ...;
                                              spec: ...;
                                              turn: ...;
                                              year: ...;
                                          };
                                      },
                                  >,
                                  InitializedType<
                                      {
                                          blank: true;
                                          choices: () => {
                                              day: ...;
                                              hour: ...;
                                              inst: ...;
                                              minute: ...;
                                              month: ...;
                                              perm: ...;
                                              round: ...;
                                              seeText: ...;
                                              spec: ...;
                                              turn: ...;
                                              year: ...;
                                          };
                                      },
                                  >,
                                  InitializedType<
                                      {
                                          blank: true;
                                          choices: () => {
                                              day: ...;
                                              hour: ...;
                                              inst: ...;
                                              minute: ...;
                                              month: ...;
                                              perm: ...;
                                              round: ...;
                                              seeText: ...;
                                              spec: ...;
                                              turn: ...;
                                              year: ...;
                                          };
                                      },
                                  >,
                              >;
                              value: StringField<
                                  DefaultOptions,
                                  AssignmentType<DefaultOptions>,
                                  InitializedType<DefaultOptions>,
                                  InitializedType<DefaultOptions>,
                              >;
                          },
                          SimpleMerge<DefaultOptions, DefaultOptions>,
                      >,
                      {
                          units: InitializedType<
                              {
                                  blank: true;
                                  choices: () => {
                                      day: "Days";
                                      hour: "Hours";
                                      inst: "Instantaneous";
                                      minute: "Minutes";
                                      month: "Months";
                                      perm: "Permanent";
                                      round: "Rounds";
                                      seeText: "See Text";
                                      spec: "Special";
                                      turn: "Turn";
                                      year: "Years";
                                  };
                              },
                          >;
                          value: InitializedType<DefaultOptions>;
                      },
                      {
                          units: InitializedType<
                              {
                                  blank: true;
                                  choices: () => {
                                      day: "Days";
                                      hour: "Hours";
                                      inst: "Instantaneous";
                                      minute: "Minutes";
                                      month: "Months";
                                      perm: "Permanent";
                                      round: "Rounds";
                                      seeText: "See Text";
                                      spec: "Special";
                                      turn: "Turn";
                                      year: "Years";
                                  };
                              },
                          >;
                          value: InitializedType<DefaultOptions>;
                      },
                  >;
                  trigger: StringField<
                      DefaultOptions,
                      AssignmentType<DefaultOptions>,
                      InitializedType<DefaultOptions>,
                      InitializedType<DefaultOptions>,
                  >;
                  weakness: StringField<
                      DefaultOptions,
                      AssignmentType<DefaultOptions>,
                      InitializedType<DefaultOptions>,
                      InitializedType<DefaultOptions>,
                  >;
              },
              DefaultOptions,
              AssignmentType<
                  {
                      alignment: StringField<
                          {
                              choices: () => {
                                  ce: "Chaotic Evil";
                                  cg: "Chaotic Good";
                                  cn: "Chaotic Neutral";
                                  le: "Lawful Evil";
                                  lg: "Lawful Good";
                                  ln: "Lawful Neutral";
                                  ne: "Neutral Evil";
                                  ng: "Neutral Good";
                                  tn: "Neutral";
                              };
                              initial: "tn";
                              required: true;
                          },
                          AssignmentType<
                              {
                                  choices: () => {
                                      ce: "Chaotic Evil";
                                      cg: "Chaotic Good";
                                      cn: "Chaotic Neutral";
                                      le: "Lawful Evil";
                                      lg: "Lawful Good";
                                      ln: "Lawful Neutral";
                                      ne: "Neutral Evil";
                                      ng: "Neutral Good";
                                      tn: "Neutral";
                                  };
                                  initial: "tn";
                                  required: true;
                              },
                          >,
                          InitializedType<
                              {
                                  choices: () => {
                                      ce: "Chaotic Evil";
                                      cg: "Chaotic Good";
                                      cn: "Chaotic Neutral";
                                      le: "Lawful Evil";
                                      lg: "Lawful Good";
                                      ln: "Lawful Neutral";
                                      ne: "Neutral Evil";
                                      ng: "Neutral Good";
                                      tn: "Neutral";
                                  };
                                  initial: "tn";
                                  required: true;
                              },
                          >,
                          InitializedType<
                              {
                                  choices: () => {
                                      ce: "Chaotic Evil";
                                      cg: "Chaotic Good";
                                      cn: "Chaotic Neutral";
                                      le: "Lawful Evil";
                                      lg: "Lawful Good";
                                      ln: "Lawful Neutral";
                                      ne: "Neutral Evil";
                                      ng: "Neutral Good";
                                      tn: "Neutral";
                                  };
                                  initial: "tn";
                                  required: true;
                              },
                          >,
                      >;
                      area: SchemaField<
                          {
                              size: NumberField<
                                  { initial: 0; integer: true; min: 0; nullable: false },
                                  AssignmentType<
                                      { initial: 0; integer: true; min: 0; nullable: false },
                                  >,
                                  InitializedType<
                                      { initial: 0; integer: true; min: 0; nullable: false },
                                  >,
                                  InitializedType<
                                      { initial: 0; integer: true; min: 0; nullable: false },
                                  >,
                              >;
                              type: StringField<
                                  {
                                      choices: () => Record<string, string>;
                                      initial: "circle";
                                      required: true;
                                  },
                                  AssignmentType<
                                      {
                                          choices: () => Record<(...), (...)>;
                                          initial: "circle";
                                          required: true;
                                      },
                                  >,
                                  string,
                                  string,
                              >;
                          },
                          DefaultOptions,
                          AssignmentType<
                              {
                                  size: NumberField<
                                      { initial: 0; integer: true; min: 0; nullable: false },
                                      AssignmentType<
                                          { initial: 0; integer: true; min: 0; nullable: false },
                                      >,
                                      InitializedType<
                                          { initial: 0; integer: true; min: 0; nullable: false },
                                      >,
                                      InitializedType<
                                          { initial: 0; integer: true; min: 0; nullable: false },
                                      >,
                                  >;
                                  type: StringField<
                                      {
                                          choices: () => Record<(...), (...)>;
                                          initial: "circle";
                                          required: true;
                                      },
                                      AssignmentType<
                                          { choices: () => ...; initial: "circle"; required: true },
                                      >,
                                      string,
                                      string,
                                  >;
                              },
                              SimpleMerge<DefaultOptions, DefaultOptions>,
                          >,
                          {
                              size: InitializedType<
                                  { initial: 0; integer: true; min: 0; nullable: false },
                              >;
                              type: string;
                          },
                          {
                              size: InitializedType<
                                  { initial: 0; integer: true; min: 0; nullable: false },
                              >;
                              type: string;
                          },
                      >;
                      aura: SchemaField<
                          {
                              custom: BooleanField<
                                  { initial: false },
                                  AssignmentType<SimpleMerge<{ initial: false }, DefaultOptions>>,
                                  InitializedType<SimpleMerge<{ initial: false }, DefaultOptions>>,
                                  InitializedType<SimpleMerge<{ initial: false }, DefaultOptions>>,
                              >;
                              school: StringField<
                                  DefaultOptions,
                                  AssignmentType<DefaultOptions>,
                                  InitializedType<DefaultOptions>,
                                  InitializedType<DefaultOptions>,
                              >;
                          },
                          DefaultOptions,
                          AssignmentType<
                              {
                                  custom: BooleanField<
                                      { initial: false },
                                      AssignmentType<SimpleMerge<{ initial: ... }, DefaultOptions>>,
                                      InitializedType<SimpleMerge<{ initial: ... }, DefaultOptions>>,
                                      InitializedType<SimpleMerge<{ initial: ... }, DefaultOptions>>,
                                  >;
                                  school: StringField<
                                      DefaultOptions,
                                      AssignmentType<DefaultOptions>,
                                      InitializedType<DefaultOptions>,
                                      InitializedType<DefaultOptions>,
                                  >;
                              },
                              SimpleMerge<DefaultOptions, DefaultOptions>,
                          >,
                          {
                              custom: InitializedType<
                                  SimpleMerge<{ initial: false }, DefaultOptions>,
                              >;
                              school: InitializedType<DefaultOptions>;
                          },
                          {
                              custom: InitializedType<
                                  SimpleMerge<{ initial: false }, DefaultOptions>,
                              >;
                              school: InitializedType<DefaultOptions>;
                          },
                      >;
                      cl: NumberField<
                          { initial: 1; integer: true; min: 1; nullable: false },
                          AssignmentType<{ initial: 1; integer: true; min: 1; nullable: false }>,
                          InitializedType<{ initial: 1; integer: true; min: 1; nullable: false }>,
                          InitializedType<{ initial: 1; integer: true; min: 1; nullable: false }>,
                      >;
                      cr: SchemaField<
                          {
                              offset: NumberField<
                                  { initial: 0; integer: true; min: 0; nullable: false },
                                  AssignmentType<
                                      { initial: 0; integer: true; min: 0; nullable: false },
                                  >,
                                  InitializedType<
                                      { initial: 0; integer: true; min: 0; nullable: false },
                                  >,
                                  InitializedType<
                                      { initial: 0; integer: true; min: 0; nullable: false },
                                  >,
                              >;
                          },
                          DefaultOptions,
                          AssignmentType<
                              {
                                  offset: NumberField<
                                      { initial: 0; integer: true; min: 0; nullable: false },
                                      AssignmentType<
                                          { initial: 0; integer: true; min: 0; nullable: false },
                                      >,
                                      InitializedType<
                                          { initial: 0; integer: true; min: 0; nullable: false },
                                      >,
                                      InitializedType<
                                          { initial: 0; integer: true; min: 0; nullable: false },
                                      >,
                                  >;
                              },
                              SimpleMerge<DefaultOptions, DefaultOptions>,
                          >,
                          {
                              offset: InitializedType<
                                  { initial: 0; integer: true; min: 0; nullable: false },
                              >;
                          },
                          {
                              offset: InitializedType<
                                  { initial: 0; integer: true; min: 0; nullable: false },
                              >;
                          },
                      >;
                      destruction: HTMLField<
                          DefaultOptions,
                          AssignmentType<DefaultOptions>,
                          string,
                          string,
                      >;
                      effect: HTMLField<
                          DefaultOptions,
                          AssignmentType<DefaultOptions>,
                          string,
                          string,
                      >;
                      notes: HTMLField<
                          DefaultOptions,
                          AssignmentType<DefaultOptions>,
                          string,
                          string,
                      >;
                      notice: SchemaField<
                          {
                              dc: NumberField<
                                  { initial: 0; integer: true; min: 0; nullable: false },
                                  AssignmentType<
                                      { initial: 0; integer: true; min: 0; nullable: false },
                                  >,
                                  InitializedType<
                                      { initial: 0; integer: true; min: 0; nullable: false },
                                  >,
                                  InitializedType<
                                      { initial: 0; integer: true; min: 0; nullable: false },
                                  >,
                              >;
                              desc: StringField<
                                  DefaultOptions,
                                  AssignmentType<DefaultOptions>,
                                  InitializedType<DefaultOptions>,
                                  InitializedType<DefaultOptions>,
                              >;
                              value: StringField<
                                  DefaultOptions,
                                  AssignmentType<DefaultOptions>,
                                  InitializedType<DefaultOptions>,
                                  InitializedType<DefaultOptions>,
                              >;
                          },
                          DefaultOptions,
                          AssignmentType<
                              {
                                  dc: NumberField<
                                      { initial: 0; integer: true; min: 0; nullable: false },
                                      AssignmentType<
                                          { initial: 0; integer: true; min: 0; nullable: false },
                                      >,
                                      InitializedType<
                                          { initial: 0; integer: true; min: 0; nullable: false },
                                      >,
                                      InitializedType<
                                          { initial: 0; integer: true; min: 0; nullable: false },
                                      >,
                                  >;
                                  desc: StringField<
                                      DefaultOptions,
                                      AssignmentType<DefaultOptions>,
                                      InitializedType<DefaultOptions>,
                                      InitializedType<DefaultOptions>,
                                  >;
                                  value: StringField<
                                      DefaultOptions,
                                      AssignmentType<DefaultOptions>,
                                      InitializedType<DefaultOptions>,
                                      InitializedType<DefaultOptions>,
                                  >;
                              },
                              SimpleMerge<DefaultOptions, DefaultOptions>,
                          >,
                          {
                              dc: InitializedType<
                                  { initial: 0; integer: true; min: 0; nullable: false },
                              >;
                              desc: InitializedType<DefaultOptions>;
                              value: InitializedType<DefaultOptions>;
                          },
                          {
                              dc: InitializedType<
                                  { initial: 0; integer: true; min: 0; nullable: false },
                              >;
                              desc: InitializedType<DefaultOptions>;
                              value: InitializedType<DefaultOptions>;
                          },
                      >;
                      reset: SchemaField<
                          {
                              units: StringField<
                                  {
                                      blank: true;
                                      choices: () => {
                                          day: "Days";
                                          hour: "Hours";
                                          inst: "Instantaneous";
                                          minute: "Minutes";
                                          month: "Months";
                                          perm: "Permanent";
                                          round: "Rounds";
                                          seeText: "See Text";
                                          spec: "Special";
                                          turn: "Turn";
                                          year: "Years";
                                      };
                                  },
                                  AssignmentType<
                                      {
                                          blank: true;
                                          choices: () => {
                                              day: ...;
                                              hour: ...;
                                              inst: ...;
                                              minute: ...;
                                              month: ...;
                                              perm: ...;
                                              round: ...;
                                              seeText: ...;
                                              spec: ...;
                                              turn: ...;
                                              year: ...;
                                          };
                                      },
                                  >,
                                  InitializedType<
                                      {
                                          blank: true;
                                          choices: () => {
                                              day: ...;
                                              hour: ...;
                                              inst: ...;
                                              minute: ...;
                                              month: ...;
                                              perm: ...;
                                              round: ...;
                                              seeText: ...;
                                              spec: ...;
                                              turn: ...;
                                              year: ...;
                                          };
                                      },
                                  >,
                                  InitializedType<
                                      {
                                          blank: true;
                                          choices: () => {
                                              day: ...;
                                              hour: ...;
                                              inst: ...;
                                              minute: ...;
                                              month: ...;
                                              perm: ...;
                                              round: ...;
                                              seeText: ...;
                                              spec: ...;
                                              turn: ...;
                                              year: ...;
                                          };
                                      },
                                  >,
                              >;
                              value: StringField<
                                  DefaultOptions,
                                  AssignmentType<DefaultOptions>,
                                  InitializedType<DefaultOptions>,
                                  InitializedType<DefaultOptions>,
                              >;
                          },
                          DefaultOptions,
                          AssignmentType<
                              {
                                  units: StringField<
                                      {
                                          blank: true;
                                          choices: () => {
                                              day: ...;
                                              hour: ...;
                                              inst: ...;
                                              minute: ...;
                                              month: ...;
                                              perm: ...;
                                              round: ...;
                                              seeText: ...;
                                              spec: ...;
                                              turn: ...;
                                              year: ...;
                                          };
                                      },
                                      AssignmentType<{ blank: true; choices: () => ... }>,
                                      InitializedType<{ blank: true; choices: () => ... }>,
                                      InitializedType<{ blank: true; choices: () => ... }>,
                                  >;
                                  value: StringField<
                                      DefaultOptions,
                                      AssignmentType<DefaultOptions>,
                                      InitializedType<DefaultOptions>,
                                      InitializedType<DefaultOptions>,
                                  >;
                              },
                              SimpleMerge<DefaultOptions, DefaultOptions>,
                          >,
                          {
                              units: InitializedType<
                                  {
                                      blank: true;
                                      choices: () => {
                                          day: "Days";
                                          hour: "Hours";
                                          inst: "Instantaneous";
                                          minute: "Minutes";
                                          month: "Months";
                                          perm: "Permanent";
                                          round: "Rounds";
                                          seeText: "See Text";
                                          spec: "Special";
                                          turn: "Turn";
                                          year: "Years";
                                      };
                                  },
                              >;
                              value: InitializedType<DefaultOptions>;
                          },
                          {
                              units: InitializedType<
                                  {
                                      blank: true;
                                      choices: () => {
                                          day: "Days";
                                          hour: "Hours";
                                          inst: "Instantaneous";
                                          minute: "Minutes";
                                          month: "Months";
                                          perm: "Permanent";
                                          round: "Rounds";
                                          seeText: "See Text";
                                          spec: "Special";
                                          turn: "Turn";
                                          year: "Years";
                                      };
                                  },
                              >;
                              value: InitializedType<DefaultOptions>;
                          },
                      >;
                      trigger: StringField<
                          DefaultOptions,
                          AssignmentType<DefaultOptions>,
                          InitializedType<DefaultOptions>,
                          InitializedType<DefaultOptions>,
                      >;
                      weakness: StringField<
                          DefaultOptions,
                          AssignmentType<DefaultOptions>,
                          InitializedType<DefaultOptions>,
                          InitializedType<DefaultOptions>,
                      >;
                  },
                  SimpleMerge<DefaultOptions, DefaultOptions>,
              >,
              {
                  alignment: InitializedType<
                      {
                          choices: () => {
                              ce: "Chaotic Evil";
                              cg: "Chaotic Good";
                              cn: "Chaotic Neutral";
                              le: "Lawful Evil";
                              lg: "Lawful Good";
                              ln: "Lawful Neutral";
                              ne: "Neutral Evil";
                              ng: "Neutral Good";
                              tn: "Neutral";
                          };
                          initial: "tn";
                          required: true;
                      },
                  >;
                  area: {
                      size: InitializedType<
                          { initial: 0; integer: true; min: 0; nullable: false },
                      >;
                      type: string;
                  };
                  aura: {
                      custom: InitializedType<
                          SimpleMerge<{ initial: false }, DefaultOptions>,
                      >;
                      school: InitializedType<DefaultOptions>;
                  };
                  cl: InitializedType<
                      { initial: 1; integer: true; min: 1; nullable: false },
                  >;
                  cr: {
                      offset: InitializedType<
                          { initial: 0; integer: true; min: 0; nullable: false },
                      >;
                  };
                  destruction: string;
                  effect: string;
                  notes: string;
                  notice: {
                      dc: InitializedType<
                          { initial: 0; integer: true; min: 0; nullable: false },
                      >;
                      desc: InitializedType<DefaultOptions>;
                      value: InitializedType<DefaultOptions>;
                  };
                  reset: {
                      units: InitializedType<
                          {
                              blank: true;
                              choices: () => {
                                  day: "Days";
                                  hour: "Hours";
                                  inst: "Instantaneous";
                                  minute: "Minutes";
                                  month: "Months";
                                  perm: "Permanent";
                                  round: "Rounds";
                                  seeText: "See Text";
                                  spec: "Special";
                                  turn: "Turn";
                                  year: "Years";
                              };
                          },
                      >;
                      value: InitializedType<DefaultOptions>;
                  };
                  trigger: InitializedType<DefaultOptions>;
                  weakness: InitializedType<DefaultOptions>;
              },
              {
                  alignment: InitializedType<
                      {
                          choices: () => {
                              ce: "Chaotic Evil";
                              cg: "Chaotic Good";
                              cn: "Chaotic Neutral";
                              le: "Lawful Evil";
                              lg: "Lawful Good";
                              ln: "Lawful Neutral";
                              ne: "Neutral Evil";
                              ng: "Neutral Good";
                              tn: "Neutral";
                          };
                          initial: "tn";
                          required: true;
                      },
                  >;
                  area: {
                      size: InitializedType<
                          { initial: 0; integer: true; min: 0; nullable: false },
                      >;
                      type: string;
                  };
                  aura: {
                      custom: InitializedType<
                          SimpleMerge<{ initial: false }, DefaultOptions>,
                      >;
                      school: InitializedType<DefaultOptions>;
                  };
                  cl: InitializedType<
                      { initial: 1; integer: true; min: 1; nullable: false },
                  >;
                  cr: {
                      offset: InitializedType<
                          { initial: 0; integer: true; min: 0; nullable: false },
                      >;
                  };
                  destruction: string;
                  effect: string;
                  notes: string;
                  notice: {
                      dc: InitializedType<
                          { initial: 0; integer: true; min: 0; nullable: false },
                      >;
                      desc: InitializedType<DefaultOptions>;
                      value: InitializedType<DefaultOptions>;
                  };
                  reset: {
                      units: InitializedType<
                          {
                              blank: true;
                              choices: () => {
                                  day: "Days";
                                  hour: "Hours";
                                  inst: "Instantaneous";
                                  minute: "Minutes";
                                  month: "Months";
                                  perm: "Permanent";
                                  round: "Rounds";
                                  seeText: "See Text";
                                  spec: "Special";
                                  turn: "Turn";
                                  year: "Years";
                              };
                          },
                      >;
                      value: InitializedType<DefaultOptions>;
                  };
                  trigger: InitializedType<DefaultOptions>;
                  weakness: InitializedType<DefaultOptions>;
              },
          >;
          templates: ArrayField<
              StringField<
                  { blank: false },
                  AssignmentType<{ blank: false }>,
                  InitializedType<{ blank: false }>,
                  InitializedType<{ blank: false }>,
              >,
              DefaultOptions,
              AssignmentType<{ blank: false }>,
              InitializedType<{ blank: false }>,
              AssignmentType<AssignmentType<{ blank: false }>, DefaultOptions>,
              InitializedType<{ blank: false }>[],
              InitializedType<{ blank: false }>,
              InitializedType<{ blank: false }>[],
          >;
          traits: SchemaField<
              {
                  size: StringField<
                      {
                          choices: () => {
                              col: "Colossal";
                              dim: "Diminutive";
                              fine: "Fine";
                              grg: "Gargantuan";
                              huge: "Huge";
                              lg: "Large";
                              med: "Medium";
                              sm: "Small";
                              tiny: "Tiny";
                          };
                          initial: "med";
                          required: true;
                      },
                      AssignmentType<
                          {
                              choices: () => {
                                  col: "Colossal";
                                  dim: "Diminutive";
                                  fine: "Fine";
                                  grg: "Gargantuan";
                                  huge: "Huge";
                                  lg: "Large";
                                  med: "Medium";
                                  sm: "Small";
                                  tiny: "Tiny";
                              };
                              initial: "med";
                              required: true;
                          },
                      >,
                      InitializedType<
                          {
                              choices: () => {
                                  col: "Colossal";
                                  dim: "Diminutive";
                                  fine: "Fine";
                                  grg: "Gargantuan";
                                  huge: "Huge";
                                  lg: "Large";
                                  med: "Medium";
                                  sm: "Small";
                                  tiny: "Tiny";
                              };
                              initial: "med";
                              required: true;
                          },
                      >,
                      InitializedType<
                          {
                              choices: () => {
                                  col: "Colossal";
                                  dim: "Diminutive";
                                  fine: "Fine";
                                  grg: "Gargantuan";
                                  huge: "Huge";
                                  lg: "Large";
                                  med: "Medium";
                                  sm: "Small";
                                  tiny: "Tiny";
                              };
                              initial: "med";
                              required: true;
                          },
                      >,
                  >;
              },
              DefaultOptions,
              AssignmentType<
                  {
                      size: StringField<
                          {
                              choices: () => {
                                  col: "Colossal";
                                  dim: "Diminutive";
                                  fine: "Fine";
                                  grg: "Gargantuan";
                                  huge: "Huge";
                                  lg: "Large";
                                  med: "Medium";
                                  sm: "Small";
                                  tiny: "Tiny";
                              };
                              initial: "med";
                              required: true;
                          },
                          AssignmentType<
                              {
                                  choices: () => {
                                      col: "Colossal";
                                      dim: "Diminutive";
                                      fine: "Fine";
                                      grg: "Gargantuan";
                                      huge: "Huge";
                                      lg: "Large";
                                      med: "Medium";
                                      sm: "Small";
                                      tiny: "Tiny";
                                  };
                                  initial: "med";
                                  required: true;
                              },
                          >,
                          InitializedType<
                              {
                                  choices: () => {
                                      col: "Colossal";
                                      dim: "Diminutive";
                                      fine: "Fine";
                                      grg: "Gargantuan";
                                      huge: "Huge";
                                      lg: "Large";
                                      med: "Medium";
                                      sm: "Small";
                                      tiny: "Tiny";
                                  };
                                  initial: "med";
                                  required: true;
                              },
                          >,
                          InitializedType<
                              {
                                  choices: () => {
                                      col: "Colossal";
                                      dim: "Diminutive";
                                      fine: "Fine";
                                      grg: "Gargantuan";
                                      huge: "Huge";
                                      lg: "Large";
                                      med: "Medium";
                                      sm: "Small";
                                      tiny: "Tiny";
                                  };
                                  initial: "med";
                                  required: true;
                              },
                          >,
                      >;
                  },
                  SimpleMerge<DefaultOptions, DefaultOptions>,
              >,
              {
                  size: InitializedType<
                      {
                          choices: () => {
                              col: "Colossal";
                              dim: "Diminutive";
                              fine: "Fine";
                              grg: "Gargantuan";
                              huge: "Huge";
                              lg: "Large";
                              med: "Medium";
                              sm: "Small";
                              tiny: "Tiny";
                          };
                          initial: "med";
                          required: true;
                      },
                  >;
              },
              {
                  size: InitializedType<
                      {
                          choices: () => {
                              col: "Colossal";
                              dim: "Diminutive";
                              fine: "Fine";
                              grg: "Gargantuan";
                              huge: "Huge";
                              lg: "Large";
                              med: "Medium";
                              sm: "Small";
                              tiny: "Tiny";
                          };
                          initial: "med";
                          required: true;
                      },
                  >;
              },
          >;
      }

      The returned value MUST be kept up to sync with the Schema type parameter.

    • Migrate candidate source data for this DataModel which may require initial cleaning or transformations.

      Parameters

      • source: any

        The candidate source data from which the model will be constructed

      Returns void

      Migrated source data, if necessary

    Settings

    Member Visibility

    On This Page

    Constructors
    Methods