diff --git a/src/module/item/base/document.ts b/src/module/item/base/document.ts
index 0a3a3001042..4647b2e8349 100644
--- a/src/module/item/base/document.ts
+++ b/src/module/item/base/document.ts
@@ -21,6 +21,7 @@ import type { ItemOriginFlag } from "@module/chat-message/data.ts";
 import { ChatMessagePF2e } from "@module/chat-message/document.ts";
 import { preImportJSON } from "@module/doc-helpers.ts";
 import { MigrationList, MigrationRunner } from "@module/migration/index.ts";
+import { Migration901ReorganizeBulkData } from "@module/migration/migrations/901-reorganize-bulk-data.ts";
 import { MigrationRunnerBase } from "@module/migration/runner/base.ts";
 import { RuleElementOptions, RuleElementPF2e, RuleElementSource, RuleElements } from "@module/rules/index.ts";
 import { processGrantDeletions } from "@module/rules/rule-element/grant-item/helpers.ts";
@@ -814,6 +815,31 @@ class ItemPF2e<TParent extends ActorPF2e | null = ActorPF2e | null> extends Item
         return super.deleteDocuments(ids, operation);
     }
 
+    /**
+     * Temporary migration to allow certain data models to work despite more recent migrations.
+     * @todo complete data models and create new migration framework
+     */
+    static override migrateData<T extends foundry.abstract.DataModel>(
+        this: ConstructorOf<T>,
+        source: ItemSourcePF2e,
+    ): T["_source"] {
+        const itemType = String(source.type);
+        const hasTypeDataModel = itemType in CONFIG.Item.dataModels;
+        if (!hasTypeDataModel) return super.migrateData(source);
+
+        const legacyVersion = R.isPlainObject(source.system.schema)
+            ? Number(source.system.schema.version) || null
+            : null;
+        const version = Number(source.system._migration?.version) || legacyVersion;
+        if (version && version < 0.901 && itemIsOfType(source, "physical")) {
+            const migration = new Migration901ReorganizeBulkData();
+            migration.updateItem(source);
+            source = fu.applySpecialKeys(source);
+        }
+
+        return super.migrateData(source);
+    }
+
     /* -------------------------------------------- */
     /*  Event Handlers                              */
     /* -------------------------------------------- */
diff --git a/src/module/item/container/data.ts b/src/module/item/container/data.ts
index 20b89ac932a..a050bcfc67e 100644
--- a/src/module/item/container/data.ts
+++ b/src/module/item/container/data.ts
@@ -1,51 +1,96 @@
-import { EquipmentTrait } from "@item/equipment/data.ts";
+import type { ModelPropsFromSchema } from "@common/data/fields.d.mts";
+import type { EquipmentTrait } from "@item/equipment/data.ts";
+import type { BasePhysicalItemSource, BulkData, PhysicalItemTraits } from "@item/physical/data.ts";
 import {
-    BasePhysicalItemSource,
-    BulkData,
-    Investable,
-    PhysicalItemTraits,
-    PhysicalSystemData,
-    PhysicalSystemSource,
-} from "@item/physical/data.ts";
+    PhysicalItemModelOmission,
+    PhysicalItemSystemModel,
+    PhysicalItemSystemSchema,
+    PhysicalItemSystemSource,
+    PhysicalItemTraitsSchema,
+} from "@item/physical/schema.ts";
+import { RarityField } from "@module/model.ts";
+import { LaxArrayField, SlugField } from "@system/schema-data-fields.ts";
+import type { ContainerPF2e } from "./document.ts";
+import fields = foundry.data.fields;
 
 type ContainerSource = BasePhysicalItemSource<"backpack", ContainerSystemSource>;
 
-type ContainerTraits = PhysicalItemTraits<EquipmentTrait>;
+class ContainerSystemData extends PhysicalItemSystemModel<ContainerPF2e, ContainerSystemSchema> {
+    declare traits: PhysicalItemTraits<EquipmentTrait>;
 
-interface ContainerSystemSource extends Investable<PhysicalSystemSource> {
-    traits: ContainerTraits;
-    stowing: boolean;
-    bulk: ContainerBulkSource;
-    collapsed: boolean;
-    usage: { value: string };
-    subitems?: never;
-}
+    declare temporary: boolean;
+
+    declare bulk: ContainerBulkData;
+
+    static override defineSchema(): ContainerSystemSchema {
+        const traits: Record<EquipmentTrait, string> = CONFIG.PF2E.equipmentTraits;
+
+        return {
+            ...super.defineSchema(),
+            traits: new fields.SchemaField({
+                otherTags: new fields.ArrayField(
+                    new SlugField({ required: true, nullable: false, initial: undefined }),
+                ),
+                value: new LaxArrayField(
+                    new fields.StringField({
+                        required: true,
+                        nullable: false,
+                        choices: traits,
+                        initial: undefined,
+                    }),
+                ),
+                rarity: new RarityField(),
+            }),
+            bulk: new fields.SchemaField({
+                value: new fields.NumberField({ required: true, nullable: false, min: 0, initial: 0 }),
+                heldOrStowed: new fields.NumberField({ required: true, nullable: false, min: 0, initial: 0.1 }),
+                capacity: new fields.NumberField({ required: true, nullable: false, min: 0, initial: 10 }),
+                ignored: new fields.NumberField({ required: true, nullable: false, min: 0, initial: 0 }),
+            }),
+            usage: new fields.SchemaField({
+                value: new fields.StringField({ required: true, nullable: false, initial: "worn" }),
+            }),
+            collapsed: new fields.BooleanField({ required: true, nullable: false, initial: false }),
+            stowing: new fields.BooleanField({ required: true, nullable: false, initial: false }),
+        };
+    }
 
-interface ContainerBulkSource {
-    value: number;
-    heldOrStowed: number;
-    capacity: number;
-    ignored: number;
+    override prepareBaseData(): void {
+        this.temporary = false;
+
+        // Simple measure to avoid self-recursive containers
+        if (this.containerId === this.parent.id) {
+            this.containerId = null;
+        }
+    }
 }
 
 interface ContainerSystemData
-    extends Omit<ContainerSystemSource, SourceOmission>,
-        Omit<Investable<PhysicalSystemData>, "subitems" | "traits"> {
-    bulk: ContainerBulkData;
-    stackGroup: null;
-}
+    extends PhysicalItemSystemModel<ContainerPF2e, ContainerSystemSchema>,
+        Omit<ModelPropsFromSchema<ContainerSystemSchema>, PhysicalItemModelOmission> {}
+
+type ContainerSystemSchema = Omit<PhysicalItemSystemSchema, "traits" | "bulk"> & {
+    traits: fields.SchemaField<PhysicalItemTraitsSchema<EquipmentTrait>>;
+    bulk: fields.SchemaField<ContainerBulkSchema>;
+    usage: fields.SchemaField<{
+        value: fields.StringField<string, string, true, false>;
+    }>;
+    collapsed: fields.BooleanField<boolean, boolean, true, false, true>;
+    stowing: fields.BooleanField<boolean, boolean, true, false, true>;
+};
 
-type SourceOmission =
-    | "apex"
-    | "bulk"
-    | "description"
-    | "hp"
-    | "identification"
-    | "material"
-    | "price"
-    | "temporary"
-    | "usage";
+type ContainerBulkSchema = {
+    value: fields.NumberField<number, number, true, false, true>;
+    heldOrStowed: fields.NumberField<number, number, true, false, true>;
+    capacity: fields.NumberField<number, number, true, false, true>;
+    ignored: fields.NumberField<number, number, true, false, true>;
+};
+
+type ContainerSystemSource = PhysicalItemSystemSource<ContainerSystemSchema> & {
+    subitems?: never;
+};
 
-interface ContainerBulkData extends ContainerBulkSource, BulkData {}
+interface ContainerBulkData extends ModelPropsFromSchema<ContainerBulkSchema>, BulkData {}
 
-export type { ContainerBulkData, ContainerSource, ContainerSystemData };
+export { ContainerSystemData };
+export type { ContainerBulkData, ContainerSource };
diff --git a/src/module/item/container/document.ts b/src/module/item/container/document.ts
index 8e150ad044b..da02152671e 100644
--- a/src/module/item/container/document.ts
+++ b/src/module/item/container/document.ts
@@ -1,11 +1,11 @@
 import type { ActorPF2e } from "@actor";
 import { InventoryBulk } from "@actor/inventory/index.ts";
-import type { EnrichmentOptions } from "@client/applications/ux/text-editor.d.mts";
 import type { DatabaseUpdateCallbackOptions } from "@common/abstract/_module.d.mts";
 import type { RawItemChatData } from "@item/base/data/index.ts";
 import type { EquipmentTrait } from "@item/equipment/data.ts";
 import { Bulk } from "@item/physical/bulk.ts";
 import { PhysicalItemPF2e } from "@item/physical/document.ts";
+import type { EnrichmentOptionsPF2e } from "@system/text-editor.ts";
 import type { ContainerSource, ContainerSystemData } from "./data.ts";
 import { hasExtraDimensionalParent } from "./helpers.ts";
 
@@ -52,15 +52,6 @@ class ContainerPF2e<TParent extends ActorPF2e | null = ActorPF2e | null> extends
         return super.bulk.plus(this.capacity.value.minus(this.bulkIgnored));
     }
 
-    override prepareBaseData(): void {
-        super.prepareBaseData();
-
-        // Simple measure to avoid self-recursive containers
-        if (this.system.containerId === this.id) {
-            this.system.containerId = null;
-        }
-    }
-
     /** Reload this container's contents following Actor embedded-document preparation */
     override prepareSiblingData(this: ContainerPF2e<ActorPF2e>): void {
         super.prepareSiblingData();
@@ -85,7 +76,7 @@ class ContainerPF2e<TParent extends ActorPF2e | null = ActorPF2e | null> extends
 
     override async getChatData(
         this: ContainerPF2e<TParent>,
-        htmlOptions: EnrichmentOptions = {},
+        htmlOptions: EnrichmentOptionsPF2e = {},
     ): Promise<RawItemChatData> {
         return this.processChatData(htmlOptions, {
             ...(await super.getChatData()),
diff --git a/src/module/item/equipment/data.ts b/src/module/item/equipment/data.ts
index 2d1a3c57aba..bfc62ad9c4a 100644
--- a/src/module/item/equipment/data.ts
+++ b/src/module/item/equipment/data.ts
@@ -1,39 +1,65 @@
+import type { ModelPropsFromSchema } from "@common/data/fields.d.mts";
 import type { PhysicalItemSource } from "@item/base/data/index.ts";
-import type {
-    BasePhysicalItemSource,
-    Investable,
-    PhysicalItemTraits,
-    PhysicalSystemData,
-    PhysicalSystemSource,
-} from "@item/physical/data.ts";
+import type { BasePhysicalItemSource, PhysicalItemTraits } from "@item/physical/data.ts";
+import {
+    type PhysicalItemModelOmission,
+    PhysicalItemSystemModel,
+    PhysicalItemSystemSchema,
+    PhysicalItemSystemSource,
+    PhysicalItemTraitsSchema,
+} from "@item/physical/schema.ts";
+import { RarityField } from "@module/model.ts";
+import { LaxArrayField, SlugField } from "@system/schema-data-fields.ts";
+import type { EquipmentPF2e } from "./document.ts";
 import type { EquipmentTrait } from "./types.ts";
+import fields = foundry.data.fields;
 
 type EquipmentSource = BasePhysicalItemSource<"equipment", EquipmentSystemSource>;
 
-interface EquipmentSystemSource extends Investable<PhysicalSystemSource> {
-    traits: EquipmentTraits;
-    usage: { value: string };
-    /** Doubly-embedded adjustments, attachments, talismans etc. */
-    subitems: PhysicalItemSource[];
-}
+class EquipmentSystemData extends PhysicalItemSystemModel<EquipmentPF2e, EquipmentSystemSchema> {
+    declare traits: PhysicalItemTraits<EquipmentTrait>;
 
-interface EquipmentTraits extends PhysicalItemTraits<EquipmentTrait> {}
+    static override defineSchema(): EquipmentSystemSchema {
+        const traits: Record<EquipmentTrait, string> = CONFIG.PF2E.equipmentTraits;
 
-interface EquipmentSystemData
-    extends Omit<EquipmentSystemSource, SourceOmission>,
-        Omit<Investable<PhysicalSystemData>, "subitems" | "traits"> {
-    stackGroup: null;
+        return {
+            ...super.defineSchema(),
+            traits: new fields.SchemaField({
+                otherTags: new fields.ArrayField(
+                    new SlugField({ required: true, nullable: false, initial: undefined }),
+                ),
+                value: new LaxArrayField(
+                    new fields.StringField({
+                        required: true,
+                        nullable: false,
+                        choices: traits,
+                        initial: undefined,
+                    }),
+                ),
+                rarity: new RarityField(),
+            }),
+            usage: new fields.SchemaField({
+                value: new fields.StringField({ required: true, nullable: false, initial: "held-in-one-hand" }),
+            }),
+            temporary: new fields.BooleanField({ required: true, nullable: false, initial: false }),
+            subitems: new fields.ArrayField(new fields.ObjectField({ required: true, nullable: false })),
+        };
+    }
 }
+interface EquipmentSystemData
+    extends PhysicalItemSystemModel<EquipmentPF2e, EquipmentSystemSchema>,
+        Omit<ModelPropsFromSchema<EquipmentSystemSchema>, PhysicalItemModelOmission> {}
+
+type EquipmentSystemSchema = Omit<PhysicalItemSystemSchema, "traits"> & {
+    traits: fields.SchemaField<PhysicalItemTraitsSchema<EquipmentTrait>>;
+    usage: fields.SchemaField<{
+        value: fields.StringField<string, string, true, false>;
+    }>;
+    temporary: fields.BooleanField<boolean, boolean, true, false, true>;
+    subitems: fields.ArrayField<fields.ObjectField<PhysicalItemSource, PhysicalItemSource, true, false>>;
+};
 
-type SourceOmission =
-    | "apex"
-    | "bulk"
-    | "description"
-    | "hp"
-    | "identification"
-    | "material"
-    | "price"
-    | "temporary"
-    | "usage";
+type EquipmentSystemSource = PhysicalItemSystemSource<EquipmentSystemSchema>;
 
-export type { EquipmentSource, EquipmentSystemData, EquipmentSystemSource, EquipmentTrait };
+export { EquipmentSystemData };
+export type { EquipmentSource, EquipmentSystemSource, EquipmentTrait };
diff --git a/src/module/item/identification.ts b/src/module/item/identification.ts
index b57d837c395..33dfdbaaeb4 100644
--- a/src/module/item/identification.ts
+++ b/src/module/item/identification.ts
@@ -1,4 +1,5 @@
 import { SkillSlug } from "@actor/types.ts";
+import type { ImageFilePath } from "@common/constants.d.mts";
 import { Rarity } from "@module/data.ts";
 import { setHasElement } from "@util";
 import { adjustDCByRarity, calculateDC, DCOptions } from "../dc.ts";
@@ -73,7 +74,7 @@ function getItemIdentificationDCs(
     }
 }
 
-function getUnidentifiedPlaceholderImage(item: PhysicalItemPF2e): string {
+function getUnidentifiedPlaceholderImage(item: PhysicalItemPF2e): ImageFilePath {
     const iconName = ((): string => {
         if (item.isOfType("weapon")) {
             const { traits } = item;
diff --git a/src/module/item/physical/data.ts b/src/module/item/physical/data.ts
index 817d2198f4f..ffccd9ec7b5 100644
--- a/src/module/item/physical/data.ts
+++ b/src/module/item/physical/data.ts
@@ -70,7 +70,7 @@ interface PhysicalSystemData extends Omit<PhysicalSystemSource, "description">,
     temporary: boolean;
     identification: IdentificationData;
     usage: UsageDetails;
-    stackGroup: string | null;
+    stackGroup?: string | null;
 }
 
 type Investable<TData extends PhysicalSystemData | PhysicalSystemSource> = TData & {
@@ -108,7 +108,7 @@ interface ItemMaterialData extends ItemMaterialSource {
 type IdentifiedData = DeepPartial<MystifiedData>;
 
 interface IdentificationData extends IdentificationSource {
-    identified: MystifiedData;
+    identified: MystifiedData & { img: ImageFilePath | null };
 }
 
 type EquippedData = {
diff --git a/src/module/item/physical/document.ts b/src/module/item/physical/document.ts
index 2a02063da54..801fb44027f 100644
--- a/src/module/item/physical/document.ts
+++ b/src/module/item/physical/document.ts
@@ -8,6 +8,7 @@ import type {
     DatabaseUpdateCallbackOptions,
     DatabaseUpdateOperation,
 } from "@common/abstract/_types.d.mts";
+import { ImageFilePath } from "@common/constants.mjs";
 import { ItemPF2e, ItemProxyPF2e, type ContainerPF2e } from "@item";
 import type { ItemSourcePF2e, PhysicalItemSource, RawItemChatData, TraitChatData } from "@item/base/data/index.ts";
 import { MystifiedTraits } from "@item/base/data/values.ts";
@@ -564,8 +565,11 @@ abstract class PhysicalItemPF2e<TParent extends ActorPF2e | null = ActorPF2e | n
     }
 
     /* Retrieve subtitution data for an unidentified or misidentified item, generating defaults as necessary */
-    getMystifiedData(status: IdentificationStatus, _options?: Record<string, boolean>): MystifiedData {
-        const mystifiedData: MystifiedData = this.system.identification[status];
+    getMystifiedData(
+        status: IdentificationStatus,
+        _options?: Record<string, boolean>,
+    ): MystifiedData & { img: ImageFilePath } {
+        const mystifiedData = this.system.identification[status];
 
         const name = mystifiedData.name || this.generateUnidentifiedName();
         const img = mystifiedData.img || getUnidentifiedPlaceholderImage(this);
diff --git a/src/module/item/physical/schema.ts b/src/module/item/physical/schema.ts
index c84139e7fa3..2f7801616a1 100644
--- a/src/module/item/physical/schema.ts
+++ b/src/module/item/physical/schema.ts
@@ -1,5 +1,31 @@
+import type { AttributeString } from "@actor/types.ts";
+import { ATTRIBUTE_ABBREVIATIONS } from "@actor/values.ts";
+import type { ImageFilePath } from "@common/constants.d.mts";
+import { ModelPropsFromSchema, SourceFromSchema } from "@common/data/fields.mjs";
+import type { PhysicalItemSource } from "@item/base/data/index.ts";
+import { ItemSystemModel, type ItemSystemSchema } from "@item/base/data/model.ts";
+import type { ItemSystemSource } from "@item/base/data/system.ts";
+import { ITEM_CARRY_TYPES } from "@item/base/data/values.ts";
+import { SIZES, type Size, type ZeroToTwo } from "@module/data.ts";
+import { RarityField } from "@module/model.ts";
+import { SlugField } from "@system/schema-data-fields.ts";
 import { CoinsPF2e } from "./coins.ts";
-import type { Price } from "./index.ts";
+import type {
+    BulkData,
+    IdentificationData,
+    IdentificationStatus,
+    ItemCarryType,
+    ItemMaterialData,
+    PhysicalItemHitPoints,
+    PhysicalItemPF2e,
+    PhysicalItemTrait,
+    PhysicalItemTraits,
+    PreciousMaterialGrade,
+    PreciousMaterialType,
+    Price,
+    UsageDetails,
+} from "./index.ts";
+import { PRECIOUS_MATERIAL_GRADES, PRECIOUS_MATERIAL_TYPES } from "./values.ts";
 import fields = foundry.data.fields;
 
 class PriceField extends fields.SchemaField<PriceSchema, fields.SourceFromSchema<PriceSchema>, Price> {
@@ -54,6 +80,128 @@ class PriceField extends fields.SchemaField<PriceSchema, fields.SourceFromSchema
     }
 }
 
+/** Base system model for physical items. */
+abstract class PhysicalItemSystemModel<
+    TItem extends PhysicalItemPF2e,
+    TSchema extends PhysicalItemSystemSchema,
+> extends ItemSystemModel<TItem, TSchema> {
+    declare traits: PhysicalItemTraits<PhysicalItemTrait>;
+
+    declare hp: PhysicalItemHitPoints;
+
+    declare bulk: BulkData;
+
+    declare material: ItemMaterialData;
+
+    declare identification: IdentificationData;
+
+    declare usage: UsageDetails;
+
+    declare subitems: PhysicalItemSource[];
+
+    static override defineSchema(): PhysicalItemSystemSchema {
+        return {
+            ...super.defineSchema(),
+            level: new fields.SchemaField({
+                value: new fields.NumberField({
+                    required: true,
+                    nullable: false,
+                    integer: true,
+                    min: 0,
+                    max: 30,
+                    initial: 0,
+                }),
+            }),
+            quantity: new fields.NumberField({ required: true, nullable: false, initial: 0, min: 0 }),
+            baseItem: new fields.StringField({ required: true, nullable: true, initial: null }),
+            bulk: new fields.SchemaField({
+                value: new fields.NumberField({ required: true, nullable: false, min: 0, initial: 0 }),
+            }),
+            material: new fields.SchemaField({
+                grade: new fields.StringField({
+                    choices: [...PRECIOUS_MATERIAL_GRADES],
+                    required: true,
+                    nullable: true,
+                    initial: null,
+                }),
+                type: new fields.StringField({
+                    choices: [...PRECIOUS_MATERIAL_TYPES],
+                    required: true,
+                    nullable: true,
+                    initial: null,
+                }),
+            }),
+            hp: new fields.SchemaField({
+                value: new fields.NumberField({ required: true, nullable: false, initial: 0, min: 0 }),
+                max: new fields.NumberField({ required: true, nullable: false, initial: 0, min: 0 }),
+            }),
+            hardness: new fields.NumberField({ required: true, nullable: false, min: 0, initial: 0 }),
+            price: new PriceField(),
+            equipped: new fields.SchemaField({
+                carryType: new fields.StringField({
+                    choices: ITEM_CARRY_TYPES,
+                    required: true,
+                    nullable: false,
+                    initial: "worn",
+                }),
+                inSlot: new fields.BooleanField({ required: false, nullable: false }),
+                handsHeld: new fields.NumberField({ required: false, nullable: false, min: 0, max: 2, integer: true }),
+                invested: new fields.BooleanField({ required: false, nullable: true, initial: null }),
+            }),
+            identification: new fields.SchemaField({
+                status: new fields.StringField({
+                    choices: ["identified", "unidentified"],
+                    required: true,
+                    nullable: false,
+                    initial: "identified",
+                }),
+                unidentified: new fields.SchemaField({
+                    name: new fields.StringField({ required: true, blank: true, nullable: false, initial: "" }),
+                    img: new fields.FilePathField<ImageFilePath, ImageFilePath, true, true, true>({
+                        required: true,
+                        categories: ["IMAGE"],
+                        nullable: true,
+                        initial: null,
+                    }),
+                    data: new fields.SchemaField({
+                        description: new fields.SchemaField({
+                            value: new fields.StringField({
+                                required: true,
+                                blank: true,
+                                nullable: false,
+                                initial: "",
+                            }),
+                        }),
+                    }),
+                }),
+                misidentified: new fields.ObjectField({ required: true, nullable: false, initial: {} }),
+            }),
+            containerId: new fields.StringField({ required: true, nullable: true, blank: false, initial: null }),
+            size: new fields.StringField({ choices: SIZES, required: true, nullable: false, initial: "med" }),
+            apex: new fields.SchemaField(
+                {
+                    attribute: new fields.StringField({
+                        choices: [...ATTRIBUTE_ABBREVIATIONS],
+                        required: true,
+                        nullable: false,
+                        initial: "str",
+                    }),
+                    selected: new fields.BooleanField({ required: false, nullable: false, initial: false }),
+                },
+                { required: false, nullable: false },
+            ),
+        };
+    }
+
+    override prepareBaseData(): void {
+        this.subitems ??= [];
+    }
+}
+
+interface PhysicalItemSystemModel<TItem extends PhysicalItemPF2e, TSchema extends PhysicalItemSystemSchema>
+    extends ItemSystemModel<TItem, TSchema>,
+        Omit<ModelPropsFromSchema<PhysicalItemSystemSchema>, "description"> {}
+
 type CoinsField = fields.SchemaField<CoinsSchema, fields.SourceFromSchema<CoinsSchema>, CoinsPF2e, true, false, true>;
 
 type CoinsSchema = {
@@ -69,4 +217,74 @@ type PriceSchema = {
     sizeSensitive: fields.BooleanField<boolean, boolean, false, false, false>;
 };
 
-export { PriceField };
+type EquippedDataSchema = {
+    carryType: fields.StringField<ItemCarryType, ItemCarryType, true, false, true>;
+    inSlot: fields.BooleanField<boolean, boolean, false, false>;
+    handsHeld: fields.NumberField<ZeroToTwo, ZeroToTwo, false, false>;
+    invested: fields.BooleanField<boolean, boolean, false, true>;
+};
+
+type ApexSchema = {
+    attribute: fields.StringField<AttributeString, AttributeString, true, false>;
+    selected: fields.BooleanField<boolean, boolean, false, false, true>;
+};
+
+type PhysicalItemTraitsSchema<T extends PhysicalItemTrait> = {
+    value: fields.ArrayField<fields.StringField<T, T, true, false, false>>;
+    rarity: RarityField;
+    otherTags: fields.ArrayField<SlugField<true, false, false>, string[], string[], true, false, true>;
+};
+
+type PhysicalItemSystemSchema = ItemSystemSchema & {
+    level: fields.SchemaField<{
+        value: fields.NumberField<number, number, true, false, true>;
+    }>;
+    quantity: fields.NumberField<number, number, true, false, true>;
+    baseItem: fields.StringField<string, string, true, true, true>;
+    bulk: fields.SchemaField<{
+        value: fields.NumberField<number, number, true, false, true>;
+    }>;
+    material: fields.SchemaField<{
+        grade: fields.StringField<PreciousMaterialGrade, PreciousMaterialGrade, true, true, true>;
+        type: fields.StringField<PreciousMaterialType, PreciousMaterialType, true, true, true>;
+    }>;
+    hp: fields.SchemaField<{
+        value: fields.NumberField<number, number, true, false, true>;
+        max: fields.NumberField<number, number, true, false, true>;
+    }>;
+    hardness: fields.NumberField<number, number, true, false, true>;
+    price: PriceField;
+    equipped: fields.SchemaField<EquippedDataSchema>;
+    identification: fields.SchemaField<{
+        status: fields.StringField<IdentificationStatus, IdentificationStatus, true, false, true>;
+        unidentified: fields.SchemaField<{
+            name: fields.StringField<string, string, true, false, true>;
+            img: fields.FilePathField<ImageFilePath, ImageFilePath, true, true, true>;
+            data: fields.SchemaField<{
+                description: fields.SchemaField<{
+                    value: fields.StringField<string, string, true, false, true>;
+                }>;
+            }>;
+        }>;
+        misidentified: fields.ObjectField<object, object, true, false>;
+    }>;
+    size: fields.StringField<Size, Size, true, false, true>;
+    containerId: fields.StringField<string, string, true, true, true>;
+    apex: fields.SchemaField<
+        ApexSchema,
+        fields.SourceFromSchema<ApexSchema>,
+        fields.ModelPropsFromSchema<ApexSchema>,
+        false,
+        false
+    >;
+};
+
+type PhysicalItemModelOmission = "description" | "bulk" | "hp" | "identification" | "material" | "usage";
+
+type PhysicalItemSystemSource<T extends PhysicalItemSystemSchema = PhysicalItemSystemSchema> = SourceFromSchema<T> & {
+    schema?: ItemSystemSource["schema"];
+    usage?: { value: string };
+};
+
+export { PhysicalItemSystemModel, PriceField };
+export type { PhysicalItemModelOmission, PhysicalItemSystemSchema, PhysicalItemSystemSource, PhysicalItemTraitsSchema };
diff --git a/src/module/migration/base.ts b/src/module/migration/base.ts
index 5c8520f78ad..0e092e3c01d 100644
--- a/src/module/migration/base.ts
+++ b/src/module/migration/base.ts
@@ -50,7 +50,7 @@ interface MigrationBase {
      * @param source Item to update. This should be an `ItemData` from the previous version.
      * @param actorSource If the item is part of an actor, this is set to the actor. For instance
      */
-    updateItem?(source: ItemSourcePF2e, actorSource?: ActorSourcePF2e): Promise<void>;
+    updateItem?(source: ItemSourcePF2e, actorSource?: ActorSourcePF2e): Promise<void> | void;
 
     /**
      * Update the macro to the latest schema version.
diff --git a/src/module/migration/migrations/901-reorganize-bulk-data.ts b/src/module/migration/migrations/901-reorganize-bulk-data.ts
index de1a199cda2..ce7e776b93e 100644
--- a/src/module/migration/migrations/901-reorganize-bulk-data.ts
+++ b/src/module/migration/migrations/901-reorganize-bulk-data.ts
@@ -9,7 +9,7 @@ import { MigrationBase } from "../base.ts";
 export class Migration901ReorganizeBulkData extends MigrationBase {
     static override version = 0.901;
 
-    override async updateItem(source: ItemSourcePF2e): Promise<void> {
+    override updateItem(source: ItemSourcePF2e): void {
         this.#migrateRules(source);
         if (!itemIsOfType(source, "physical")) return;
 
diff --git a/src/scripts/hooks/load.ts b/src/scripts/hooks/load.ts
index c4a483f8db2..ca9ade1e118 100644
--- a/src/scripts/hooks/load.ts
+++ b/src/scripts/hooks/load.ts
@@ -14,7 +14,9 @@ import { AfflictionSystemData } from "@item/affliction/data.ts";
 import { CampaignFeatureSystemData } from "@item/campaign-feature/data.ts";
 import { ClassSystemData } from "@item/class/data.ts";
 import { ConditionSystemData } from "@item/condition/data.ts";
+import { ContainerSystemData } from "@item/container/data.ts";
 import { EffectSystemData } from "@item/effect/data.ts";
+import { EquipmentSystemData } from "@item/equipment/data.ts";
 import { FeatSystemData } from "@item/feat/data.ts";
 import { HeritageSystemData } from "@item/heritage/data.ts";
 import { KitSystemData } from "@item/kit/data.ts";
@@ -105,10 +107,12 @@ export const Load = {
             CONFIG.Item.dataModels.affliction = AfflictionSystemData;
         }
         CONFIG.Item.dataModels.action = AbilitySystemData;
+        CONFIG.Item.dataModels.backpack = ContainerSystemData;
         CONFIG.Item.dataModels.campaignFeature = CampaignFeatureSystemData;
         CONFIG.Item.dataModels.class = ClassSystemData;
         CONFIG.Item.dataModels.condition = ConditionSystemData;
         CONFIG.Item.dataModels.effect = EffectSystemData;
+        CONFIG.Item.dataModels.equipment = EquipmentSystemData;
         CONFIG.Item.dataModels.feat = FeatSystemData;
         CONFIG.Item.dataModels.heritage = HeritageSystemData;
         CONFIG.Item.dataModels.kit = KitSystemData;
diff --git a/static/template.json b/static/template.json
index 8ee34b39e84..5d1969b67fd 100644
--- a/static/template.json
+++ b/static/template.json
@@ -333,24 +333,6 @@
                 }
             }
         },
-        "backpack": {
-            "templates": [
-                "common",
-                "physical",
-                "investable"
-            ],
-            "bulk": {
-                "value": 0,
-                "heldOrStowed": 0.1,
-                "capacity": 10,
-                "ignored": 0
-            },
-            "collapsed": false,
-            "stowing": false,
-            "usage": {
-                "value": "worn"
-            }
-        },
         "book": {
             "templates": [
                 "common",
@@ -448,17 +430,6 @@
                 ]
             }
         },
-        "equipment": {
-            "templates": [
-                "common",
-                "physical",
-                "investable"
-            ],
-            "usage": {
-                "value": "held-in-one-hand"
-            },
-            "subitems": []
-        },
         "ancestry": {
             "templates": [
                 "common",
diff --git a/types/foundry/common/utils/helpers.d.mts b/types/foundry/common/utils/helpers.d.mts
index c05ef8f7bb1..44cb2d2da3a 100644
--- a/types/foundry/common/utils/helpers.d.mts
+++ b/types/foundry/common/utils/helpers.d.mts
@@ -142,6 +142,13 @@ export function diffObject<T extends Record<string, unknown> = Record<string, un
     other: object,
 ): T;
 
+/**
+ * Recurse through an object, applying all special keys.
+ * Deletion keys ("-=") are removed.
+ * Forced replacement keys ("==") are assigned.
+ */
+export function applySpecialKeys<T>(obj: T): T;
+
 /**
  * Test if two objects contain the same enumerable keys and values.
  * @param a  The first object.