@optolith/database-schema 0.106.0 → 0.107.0

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

@@ -320,6 +320,30 @@ export declare const Item: DB.Entity<"Item", {
             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/Item.js

@@ -2,6 +2,7 @@ import { isNotEmpty } from "@elyukai/utils/array/nonEmpty";
 import { isNotNullish } from "@elyukai/utils/nullable";
 import * as DB from "tsondb/schema/dsl";
 import { EquipmentCategoryIdentifier } from "../../_Identifier.js";
+import { EquipmentPrerequisites } from "../../_Prerequisite.js";
 import { CloseCombatTechnique, RangedCombatTechnique } from "../../CombatTechnique.js";
 import { NestedTranslationMap } from "../../Locale.js";
 import { Errata } from "../../source/_Erratum.js";
@@ -73,6 +74,10 @@ export const Item = 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, "Item", DB.Object({
             name: DB.Required({

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

@@ -86,6 +86,30 @@ export declare const ItemComponent: DB.Entity<"ItemComponent", {
             breakingPointRating: DB.MemberDecl<DB.Integer, false>;
         }>, []>>, 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/ItemComponent.js

@@ -1,5 +1,6 @@
 import * as DB from "tsondb/schema/dsl";
 import { AmmunitionIdentifier, ArmorIdentifier, CloseCombatTechniqueIdentifier, ItemComponentIdentifier, RangedCombatTechniqueIdentifier, WeaponIdentifier, } from "../../_Identifier.js";
+import { EquipmentPrerequisites } from "../../_Prerequisite.js";
 import { CloseCombatTechnique, RangedCombatTechnique } from "../../CombatTechnique.js";
 import { NestedTranslationMap } from "../../Locale.js";
 import { Errata } from "../../source/_Erratum.js";
@@ -35,6 +36,10 @@ export const ItemComponent = DB.Entity(import.meta.url, {
             comment: "Special rules for the item component.",
             type: DB.IncludeIdentifier(ItemComponentRules),
         }),
+        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, "ItemComponent", DB.Object({
             name: DB.Required({

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

@@ -88,6 +88,30 @@ export declare const Jewelry: DB.Entity<"Jewelry", {
             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/Jewelry.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, DefaultItemTranslations, StructurePoints, Weight } from "./_Item.js";
 export const Jewelry = DB.Entity(import.meta.url, {
@@ -23,6 +24,10 @@ export const Jewelry = 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("Jewelry"),
     }),

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

@@ -96,6 +96,30 @@ export declare const Laboratory: DB.Entity<"Laboratory", {
         }>, []>>>;
     }, []>>, false>;
     level: DB.MemberDecl<DB.Integer, 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/Laboratory.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 Laboratory = DB.Entity(import.meta.url, {
@@ -21,6 +22,10 @@ export const Laboratory = DB.Entity(import.meta.url, {
             comment: "The level of the laboratory.",
             type: DB.Integer({ minimum: 1 }),
         }),
+        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("Laboratory"),
     }),

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

@@ -271,6 +271,30 @@ export declare const Liebesspielzeug: DB.Entity<"Liebesspielzeug", {
             }>, 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/Liebesspielzeug.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 Liebesspielzeug = 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("Liebesspielzeug"),
     }),

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

@@ -271,6 +271,30 @@ export declare const LuxuryGood: DB.Entity<"LuxuryGood", {
             }>, 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/LuxuryGood.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 LuxuryGood = 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("LuxuryGood"),
     }),

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

@@ -271,6 +271,30 @@ export declare const MagicalArtifact: DB.Entity<"MagicalArtifact", {
             }>, 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/MagicalArtifact.js

@@ -1,4 +1,5 @@
 import * as DB from "tsondb/schema/dsl";
+import { EquipmentPrerequisites } from "../../_Prerequisite.js";
 import { NestedTranslationMap } from "../../Locale.js";
 import { Errata } from "../../source/_Erratum.js";
 import { src } from "../../source/_PublicationRef.js";
@@ -28,6 +29,10 @@ export const MagicalArtifact = 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: NestedTranslationMap(DB.Required, `MagicalArtifact`, DB.Object({
             name: DB.Required({

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

@@ -271,6 +271,30 @@ export declare const MusicalInstrument: DB.Entity<"MusicalInstrument", {
             }>, 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/MusicalInstrument.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 MusicalInstrument = 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("MusicalInstrument"),
     }),

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

@@ -270,6 +270,30 @@ export declare const OrienteeringAid: 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/Poison.d.ts

@@ -341,6 +341,30 @@ export declare const Poison: DB.Entity<"Poison", {
             }>, 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/Poison.js

@@ -4,6 +4,7 @@ import { Dice } from "../../_Dice.js";
 import { Reduceable, Resistance } from "../../_DiseasePoison.js";
 import { DiseaseIdentifier } from "../../_Identifier.js";
 import { MathOperation } from "../../_MathExpression.js";
+import { EquipmentPrerequisites } from "../../_Prerequisite.js";
 import { NestedTranslationMap } from "../../Locale.js";
 import { Errata } from "../../source/_Erratum.js";
 import { src } from "../../source/_PublicationRef.js";
@@ -44,6 +45,10 @@ export const Poison = DB.Entity(import.meta.url, {
             comment: "Price for one dose, in silverthalers.",
             type: DB.IncludeIdentifier(PoisonCost),
         }),
+        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, "Poison", DB.Object({
             name: DB.Required({

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

@@ -270,6 +270,30 @@ export declare const RopeOrChain: 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/Stationery.d.ts

@@ -270,6 +270,30 @@ export declare const Stationery: 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, {