@optolith/database-schema 0.106.0 → 0.107.0

package/lib/types/equipment/item/ThievesTool.d.ts

@@ -270,6 +270,30 @@ export declare const ThievesTool: import("tsondb/schema/dsl").Entity<string, {
             }>, false>;
         }>, []>>>;
     }, []>>, false>;
+    prerequisites: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"EquipmentPrerequisites", import("tsondb/schema/dsl").IncludeIdentifier<import("tsondb/schema/dsl").Param<string, import("tsondb/schema/dsl").Type>[], import("tsondb/schema/dsl").TypeAlias<"PlainPrerequisites", import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").IncludeIdentifier<import("tsondb/schema/dsl").Param<string, import("tsondb/schema/dsl").Type>[], import("tsondb/schema/dsl").Enum<"PrerequisitesElement", {
+        Single: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").TypeArgument<import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>>>;
+        Disjunction: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<import("tsondb/schema/dsl").Param<string, import("tsondb/schema/dsl").Type>[], import("tsondb/schema/dsl").TypeAlias<"PrerequisitesDisjunction", import("tsondb/schema/dsl").Object<{
+            list: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").TypeArgument<import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>>>, true>;
+            display_option: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"DisplayOption", {
+                Hide: import("tsondb/schema/dsl").EnumCase<null>;
+                ReplaceWith: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"ReplacementDisplayOption", import("tsondb/schema/dsl").Object<{
+                    sentence_type: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"SentenceType", {
+                        Standalone: import("tsondb/schema/dsl").EnumCase<null>;
+                        Connected: import("tsondb/schema/dsl").EnumCase<null>;
+                    }, []>>, false>;
+                    translations: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                        replacement: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, false>;
+        }>, [T: import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>]>>>;
+        Group: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<import("tsondb/schema/dsl").Param<string, import("tsondb/schema/dsl").Type>[], import("tsondb/schema/dsl").TypeAlias<"PrerequisiteGroup", import("tsondb/schema/dsl").Object<{
+            list: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").TypeArgument<import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>>>, true>;
+            translations: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").NestedEntityMap<"PrerequisiteGroupTranslation", {
+                text: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").String, true>;
+            }>, true>;
+        }>, [T: import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>]>>>;
+    }, [T: import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>]>>>, [T: import("tsondb/schema/dsl").Param<"T", import("tsondb/schema/dsl").Type>]>>, []>>, false>;
     src: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"PublicationRefs", import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"PublicationRef", import("tsondb/schema/dsl").Object<{
         id: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
         occurrences: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").NestedEntityMap<string, {

package/lib/types/equipment/item/ToolOfTheTrade.d.ts

@@ -101,6 +101,30 @@ export declare const ToolOfTheTrade: DB.Entity<"ToolOfTheTrade", {
             points: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>, []>>>;
     }, []>>, true>;
+    prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EquipmentPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+        Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+        Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                Hide: DB.EnumCase<null>;
+                ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                    sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                        Standalone: DB.EnumCase<null>;
+                        Connected: DB.EnumCase<null>;
+                    }, []>>, false>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                        replacement: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, false>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+        Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                text: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+    }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
     src: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRefs", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRef", DB.Object<{
         id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
         occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {

package/lib/types/equipment/item/ToolOfTheTrade.js

@@ -1,4 +1,5 @@
 import * as DB from "tsondb/schema/dsl";
+import { EquipmentPrerequisites } from "../../_Prerequisite.js";
 import { src } from "../../source/_PublicationRef.js";
 import { Complexity, Cost, DefaultItemTranslations, StructurePoints, Weight } from "./_Item.js";
 export const ToolOfTheTrade = DB.Entity(import.meta.url, {
@@ -21,6 +22,10 @@ export const ToolOfTheTrade = DB.Entity(import.meta.url, {
             comment: "The structure points of the item. Use an array if the item consists of multiple components that have individual structure points.",
             type: DB.IncludeIdentifier(StructurePoints),
         }),
+        prerequisites: DB.Optional({
+            comment: "The prerequisites of the item, if any. Note that this is fully separate from the prerequisites of the item’s trade secret, which are defined independently from this.",
+            type: DB.IncludeIdentifier(EquipmentPrerequisites),
+        }),
         src,
         translations: DefaultItemTranslations("ToolOfTheTrade"),
     }),

package/lib/types/equipment/item/TravelGearOrTool.d.ts

@@ -271,6 +271,30 @@ export declare const TravelGearOrTool: DB.Entity<"TravelGearOrTool", {
             }>, false>;
         }>, []>>>;
     }, []>>, false>;
+    prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EquipmentPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+        Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+        Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                Hide: DB.EnumCase<null>;
+                ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                    sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                        Standalone: DB.EnumCase<null>;
+                        Connected: DB.EnumCase<null>;
+                    }, []>>, false>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                        replacement: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, false>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+        Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                text: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+    }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
     src: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRefs", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRef", DB.Object<{
         id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
         occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {

package/lib/types/equipment/item/TravelGearOrTool.js

@@ -1,4 +1,5 @@
 import * as DB from "tsondb/schema/dsl";
+import { EquipmentPrerequisites } from "../../_Prerequisite.js";
 import { src } from "../../source/_PublicationRef.js";
 import { CombatUse, Complexity, Cost, DefaultItemTranslations, StructurePoints, Weight, } from "./_Item.js";
 import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
@@ -26,6 +27,10 @@ export const TravelGearOrTool = DB.Entity(import.meta.url, {
             comment: "The item can also be used either as an improvised weapon or as an armor, although this is not the primary use case of the item.",
             type: DB.IncludeIdentifier(CombatUse),
         }),
+        prerequisites: DB.Optional({
+            comment: "The prerequisites of the item, if any. Note that this is fully separate from the prerequisites of the item’s trade secret, which are defined independently from this.",
+            type: DB.IncludeIdentifier(EquipmentPrerequisites),
+        }),
         src,
         translations: DefaultItemTranslations("TravelGearOrTool"),
     }),

package/lib/types/equipment/item/Vehicle.d.ts

@@ -95,6 +95,30 @@ export declare const Vehicle: DB.Entity<"Vehicle", {
             }>, []>>>, []>>, false>;
         }>, []>>>;
     }, []>>, false>;
+    prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EquipmentPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+        Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+        Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                Hide: DB.EnumCase<null>;
+                ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                    sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                        Standalone: DB.EnumCase<null>;
+                        Connected: DB.EnumCase<null>;
+                    }, []>>, false>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                        replacement: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, false>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+        Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                text: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+    }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
     src: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRefs", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRef", DB.Object<{
         id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
         occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {

package/lib/types/equipment/item/Vehicle.js

@@ -1,4 +1,5 @@
 import * as DB from "tsondb/schema/dsl";
+import { EquipmentPrerequisites } from "../../_Prerequisite.js";
 import { src } from "../../source/_PublicationRef.js";
 import { Complexity, Cost, DefaultItemTranslations, Weight } from "./_Item.js";
 export const Vehicle = DB.Entity(import.meta.url, {
@@ -17,6 +18,10 @@ export const Vehicle = DB.Entity(import.meta.url, {
             comment: "The complexity of crafting the item.",
             type: DB.IncludeIdentifier(Complexity),
         }),
+        prerequisites: DB.Optional({
+            comment: "The prerequisites of the item, if any. Note that this is fully separate from the prerequisites of the item’s trade secret, which are defined independently from this.",
+            type: DB.IncludeIdentifier(EquipmentPrerequisites),
+        }),
         src,
         translations: DefaultItemTranslations("Vehicle"),
     }),

package/lib/types/equipment/item/Weapon.d.ts

@@ -231,6 +231,30 @@ export declare const Weapon: DB.Entity<"Weapon", {
             Invaluable: DB.EnumCase<null>;
         }, []>>, true>;
     }>, []>>, false>;
+    prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EquipmentPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+        Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+        Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                Hide: DB.EnumCase<null>;
+                ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                    sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                        Standalone: DB.EnumCase<null>;
+                        Connected: DB.EnumCase<null>;
+                    }, []>>, false>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                        replacement: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, false>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+        Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                text: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+    }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
     src: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRefs", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRef", DB.Object<{
         id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
         occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {

package/lib/types/equipment/item/Weapon.js

@@ -1,4 +1,5 @@
 import * as DB from "tsondb/schema/dsl";
+import { EquipmentPrerequisites } from "../../_Prerequisite.js";
 import { CloseCombatTechnique, RangedCombatTechnique } from "../../CombatTechnique.js";
 import { NestedTranslationMap } from "../../Locale.js";
 import { Errata } from "../../source/_Erratum.js";
@@ -55,6 +56,10 @@ export const Weapon = DB.Entity(import.meta.url, {
             comment: "The weapon is a known item, which implies some additional values.",
             type: DB.IncludeIdentifier(KnownItemSpecifics),
         }),
+        prerequisites: DB.Optional({
+            comment: "The prerequisites of the item, if any. Note that this is fully separate from the prerequisites of the item’s trade secret, which are defined independently from this.",
+            type: DB.IncludeIdentifier(EquipmentPrerequisites),
+        }),
         src,
         translations: NestedTranslationMap(DB.Required, "Weapon", DB.Object({
             name: DB.Required({

package/lib/types/equipment/item/WeaponAccessory.d.ts

@@ -271,6 +271,30 @@ export declare const WeaponAccessory: DB.Entity<"WeaponAccessory", {
             }>, false>;
         }>, []>>>;
     }, []>>, false>;
+    prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EquipmentPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+        Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+        Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                Hide: DB.EnumCase<null>;
+                ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                    sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                        Standalone: DB.EnumCase<null>;
+                        Connected: DB.EnumCase<null>;
+                    }, []>>, false>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                        replacement: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, false>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+        Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                text: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+    }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
     src: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRefs", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRef", DB.Object<{
         id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
         occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {

package/lib/types/equipment/item/WeaponAccessory.js

@@ -1,4 +1,5 @@
 import * as DB from "tsondb/schema/dsl";
+import { EquipmentPrerequisites } from "../../_Prerequisite.js";
 import { src } from "../../source/_PublicationRef.js";
 import { CombatUse, Complexity, Cost, DefaultItemTranslations, StructurePoints, Weight, } from "./_Item.js";
 import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
@@ -26,6 +27,10 @@ export const WeaponAccessory = DB.Entity(import.meta.url, {
             comment: "The item can also be used either as an improvised weapon or as an armor, although this is not the primary use case of the item.",
             type: DB.IncludeIdentifier(CombatUse),
         }),
+        prerequisites: DB.Optional({
+            comment: "The prerequisites of the item, if any. Note that this is fully separate from the prerequisites of the item’s trade secret, which are defined independently from this.",
+            type: DB.IncludeIdentifier(EquipmentPrerequisites),
+        }),
         src,
         translations: DefaultItemTranslations("WeaponAccessory"),
     }),

package/lib/types/equipment/item/_Item.d.ts

@@ -271,6 +271,30 @@ export declare const DefaultItem: (sourceUrl: string, singularName: string, plur
             }>, false>;
         }>, []>>>;
     }, []>>, false>;
+    prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EquipmentPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+        Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+        Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                Hide: DB.EnumCase<null>;
+                ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                    sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                        Standalone: DB.EnumCase<null>;
+                        Connected: DB.EnumCase<null>;
+                    }, []>>, false>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                        replacement: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, false>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+        Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                text: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+    }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
     src: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRefs", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRef", DB.Object<{
         id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
         occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {

package/lib/types/equipment/item/_Item.js

@@ -1,6 +1,6 @@
 import * as DB from "tsondb/schema/dsl";
 import { BlessedTraditionIdentifier, CultureIdentifier, MagicalTraditionIdentifier, ProfessionIdentifier, RaceIdentifier, } from "../../_Identifier.js";
-import { PlainGeneralPrerequisites } from "../../_Prerequisite.js";
+import { EquipmentPrerequisites, PlainGeneralPrerequisites } from "../../_Prerequisite.js";
 import { ResponsiveTextOptional, ResponsiveTextReplace } from "../../_ResponsiveText.js";
 import { NestedTranslationMap } from "../../Locale.js";
 import { Errata } from "../../source/_Erratum.js";
@@ -33,6 +33,10 @@ export const DefaultItem = (sourceUrl, singularName, pluralName) => DB.Entity(so
             comment: "The item can also be used either as an improvised weapon or as an armor, although this is not the primary use case of the item.",
             type: DB.IncludeIdentifier(CombatUse),
         }),
+        prerequisites: DB.Optional({
+            comment: "The prerequisites of the item, if any. Note that this is fully separate from the prerequisites of the item’s trade secret, which are defined independently from this.",
+            type: DB.IncludeIdentifier(EquipmentPrerequisites),
+        }),
         src,
         translations: DefaultItemTranslations(singularName),
     }),

package/lib/types/prerequisites/PrerequisiteGroups.d.ts

@@ -2295,6 +2295,27 @@ export declare const BookPrerequisiteGroup: DB.Enum<"BookPrerequisiteGroup", {
         id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
     }>, []>>>;
 }, []>;
+export declare const EquipmentPrerequisiteGroup: DB.Enum<"EquipmentPrerequisiteGroup", {
+    Rule: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"RulePrerequisite", DB.Object<{
+        id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ExtensionRuleIdentifier", {
+            FocusRule: DB.EnumCase<DB.ReferenceIdentifier>;
+            OptionalRule: DB.EnumCase<DB.ReferenceIdentifier>;
+        }, []>>, true>;
+        active: DB.MemberDecl<DB.Boolean, true>;
+        display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+            Hide: DB.EnumCase<null>;
+            ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                    Standalone: DB.EnumCase<null>;
+                    Connected: DB.EnumCase<null>;
+                }, []>>, false>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                    replacement: DB.MemberDecl<DB.String, true>;
+                }>, true>;
+            }>, []>>>;
+        }, []>>, false>;
+    }>, []>>>;
+}, []>;
 export declare const PreconditionGroup: DB.Enum<"PreconditionGroup", {
     Publication: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationPrerequisite", DB.Object<{
         id: DB.MemberDecl<DB.ReferenceIdentifier, true>;

package/lib/types/prerequisites/PrerequisiteGroups.js

@@ -189,6 +189,12 @@ export const BookPrerequisiteGroup = DB.Enum(import.meta.url, {
         Script: DB.EnumCase({ type: DB.IncludeIdentifier(ScriptPrerequisite) }),
     }),
 });
+export const EquipmentPrerequisiteGroup = DB.Enum(import.meta.url, {
+    name: "EquipmentPrerequisiteGroup",
+    values: () => ({
+        Rule: DB.EnumCase({ type: DB.IncludeIdentifier(RulePrerequisite) }),
+    }),
+});
 export const PreconditionGroup = DB.Enum(import.meta.url, {
     name: "PreconditionGroup",
     values: () => ({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optolith/database-schema",
-  "version": "0.106.0",
+  "version": "0.107.0",
   "description": "Definitions and utilities for the flat-file database of Optolith, a character creation tool for the Pen and Paper RPG “The Dark Eye 5”, and its external integrations into other software.",
   "keywords": [
     "tde",