@optolith/database-schema 0.92.0 → 0.94.0

package/lib/types/Profession.js

@@ -315,7 +315,7 @@ const VariantSpecialAbilityAction = DB.Enum(import.meta.url, {
 const ProfessionSpecialAbility = DB.Enum(import.meta.url, {
     name: "ProfessionSpecialAbility",
     values: () => ({
-        Constant: DB.EnumCase({ type: DB.IncludeIdentifier(ConstantProfessionSpecialAbility) }),
+        Constant: DB.EnumCase({ type: DB.IncludeIdentifier(SingleProfessionSpecialAbility) }),
         Selection: DB.EnumCase({ type: DB.IncludeIdentifier(ProfessionSpecialAbilitySelection) }),
     }),
 });
@@ -323,35 +323,32 @@ const ProfessionSpecialAbilityOption = DB.Enum(import.meta.url, {
     name: "ProfessionSpecialAbilityOption",
     values: () => ({
         Identifier: DB.EnumCase({
-            comment: "The option is defined by the profession.",
+            comment: "The option is a option specified in the database.",
             type: DB.IncludeIdentifier(RequirableSelectOptionIdentifier),
         }),
+        Text: DB.EnumCase({
+            comment: "The option is a text.",
+            type: DB.IncludeIdentifier(ProfessionSpecialAbilityTextOption),
+        }),
         Select: DB.EnumCase({
             comment: "The option has to be chosen when applying the profession.",
             type: null,
         }),
     }),
 });
-const ConstantProfessionSpecialAbility = DB.TypeAlias(import.meta.url, {
-    name: "ConstantProfessionSpecialAbility",
+const ProfessionSpecialAbilityTextOption = DB.TypeAlias(import.meta.url, {
+    name: "ProfessionSpecialAbilityTextOption",
     type: () => DB.Object({
-        id: DB.Required({
-            comment: "The identifier of the special ability to grant.",
-            type: DB.IncludeIdentifier(ProfessionSpecialAbilityIdentifier),
-        }),
-        level: DB.Optional({
-            comment: "The level of the received special ability. If not specified and the special ability has levels, level 1 is used automatically.",
-            type: DB.Integer({ minimum: 1 }),
-        }),
-        options: DB.Optional({
-            comment: "Received select options. Order is important. Typically, you only need the first array index, though.",
-            type: DB.Array(DB.IncludeIdentifier(ProfessionSpecialAbilityOption), { minItems: 1 }),
-        }),
+        translations: NestedTranslationMap(DB.Required, "ProfessionSpecialAbilityTextOption", DB.Object({
+            text: DB.Required({
+                comment: "The text of the option.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
     }),
-    customConstraints: ({ instanceContent, getInstanceById, getAllChildInstancesForParent }) => verifyOptionsForActivatableEntry(instanceContent, getInstanceById, getAllChildInstancesForParent),
 });
-const ProfessionSpecialAbilitySelectionItem = DB.TypeAlias(import.meta.url, {
-    name: "ProfessionSpecialAbilitySelectionItem",
+const SingleProfessionSpecialAbility = DB.TypeAlias(import.meta.url, {
+    name: "SingleProfessionSpecialAbility",
     type: () => DB.Object({
         id: DB.Required({
             comment: "The identifier of the special ability to grant.",
@@ -363,7 +360,7 @@ const ProfessionSpecialAbilitySelectionItem = DB.TypeAlias(import.meta.url, {
         }),
         options: DB.Optional({
             comment: "Received select options. Order is important. Typically, you only need the first array index, though.",
-            type: DB.Array(DB.IncludeIdentifier(RequirableSelectOptionIdentifier), { minItems: 1 }),
+            type: DB.Array(DB.IncludeIdentifier(ProfessionSpecialAbilityOption), { minItems: 1 }),
         }),
     }),
     customConstraints: ({ instanceContent, getInstanceById, getAllChildInstancesForParent }) => verifyOptionsForActivatableEntry(instanceContent, getInstanceById, getAllChildInstancesForParent),
@@ -373,7 +370,7 @@ const ProfessionSpecialAbilitySelection = DB.TypeAlias(import.meta.url, {
     type: () => DB.Object({
         options: DB.Required({
             comment: `The list of special abilities to choose from. Must contain at least two entries.`,
-            type: DB.Array(DB.IncludeIdentifier(ProfessionSpecialAbilitySelectionItem), {
+            type: DB.Array(DB.IncludeIdentifier(SingleProfessionSpecialAbility), {
                 minItems: 2,
             }),
         }),

package/lib/types/Settings.d.ts

@@ -59,6 +59,62 @@ export declare const Settings: DB.SingletonEntity<"Settings", {
             VampiricGift: DB.EnumCase<DB.ReferenceIdentifier>;
             Vision: DB.EnumCase<DB.ReferenceIdentifier>;
         }, []>>, true>;
+        requiredSpecialAbilityForAmmunition: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+            ArcaneOrbEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+            AttireEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+            Beutelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+            BowlEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+            CauldronEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+            ChronicleEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+            DaggerRitual: DB.EnumCase<DB.ReferenceIdentifier>;
+            FoolsHatEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+            Haubenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+            Hauerkettenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+            InstrumentEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+            Keulenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+            Krallenkettenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+            Kristallkugelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+            OrbEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+            RingEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+            Schweinetrommelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+            SickleRitual: DB.EnumCase<DB.ReferenceIdentifier>;
+            SpellSwordEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+            StaffEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+            ToyEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+            Trinkhornzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+            WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+            WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+            AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+            AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+            AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+            AdvancedSkillSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+            AncestorGlyph: DB.EnumCase<DB.ReferenceIdentifier>;
+            BlessedTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+            BrawlingSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+            CeremonialItemSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+            CombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+            CombatStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+            CommandSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+            FamiliarSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+            FatePointSexSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+            FatePointSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+            GeneralSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+            KarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+            LiturgicalStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+            LycantropicGift: DB.EnumCase<DB.ReferenceIdentifier>;
+            MagicalSign: DB.EnumCase<DB.ReferenceIdentifier>;
+            MagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+            MagicalTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+            MagicStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+            PactGift: DB.EnumCase<DB.ReferenceIdentifier>;
+            ProtectiveWardingCircleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+            Sermon: DB.EnumCase<DB.ReferenceIdentifier>;
+            SexSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+            SikaryanDrainSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+            SkillStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+            VampiricGift: DB.EnumCase<DB.ReferenceIdentifier>;
+            Vision: DB.EnumCase<DB.ReferenceIdentifier>;
+        }, []>>, true>;
         requiredSpecialAbilityForArmor: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
             ArcaneOrbEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
             AttireEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;

package/lib/types/Settings.js

@@ -52,6 +52,11 @@ const DerivedTradeSecretsSettings = DB.TypeAlias(import.meta.url, {
             comment: "The special ability required to buy derived trade secrets for weapons.",
             type: DB.IncludeIdentifier(SpecialAbilityIdentifier),
         }),
+        requiredSpecialAbilityForAmmunition: DB.Required({
+            displayName: "Required Special Ability for Ammunition",
+            comment: "The special ability required to buy derived trade secrets for ammunition.",
+            type: DB.IncludeIdentifier(SpecialAbilityIdentifier),
+        }),
         requiredSpecialAbilityForArmor: DB.Required({
             displayName: "Required Special Ability for Armor",
             comment: "The special ability required to buy derived trade secrets for armor.",

package/lib/types/_ActivatableSelectOptionCategory.d.ts

@@ -830,6 +830,9 @@ export declare const SelectOptionCategory: DB.Enum<"SelectOptionCategory", {
             volume: DB.MemberDecl<DB.Integer, false>;
         }>, []>>>, true>;
     }>, []>>>;
+    Advantages: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdvantagesSelectOptionCategory", DB.Object<{
+        dependingOn: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+    }>, []>>>;
 }, []>;
 export declare const TradeSecretSelectOptionCategory: DB.Enum<"TradeSecretSelectOptionCategory", {
     Blessings: DB.EnumCase<null>;

package/lib/types/_ActivatableSelectOptionCategory.js

@@ -1,5 +1,5 @@
 import * as DB from "tsondb/schema/dsl";
-import { CeremonyIdentifier, CloseCombatTechniqueIdentifier, ElementIdentifier, LiturgicalChantIdentifier, PropertyIdentifier, RangedCombatTechniqueIdentifier, RitualIdentifier, SkillGroupIdentifier, SkillIdentifier, SpellIdentifier, TargetCategoryIdentifier, } from "./_Identifier.js";
+import { AdvantageIdentifier, CeremonyIdentifier, CloseCombatTechniqueIdentifier, ElementIdentifier, LiturgicalChantIdentifier, PropertyIdentifier, RangedCombatTechniqueIdentifier, RitualIdentifier, SkillGroupIdentifier, SkillIdentifier, SpellIdentifier, TargetCategoryIdentifier, } from "./_Identifier.js";
 import { ActivatableIdentifier, CombatTechniqueIdentifier, SkillishIdentifier, } from "./_IdentifierGroup.js";
 import { NestedTranslationMap } from "./Locale.js";
 export const SelectOptionCategory = DB.Enum(import.meta.url, {
@@ -33,6 +33,9 @@ export const SelectOptionCategory = DB.Enum(import.meta.url, {
         TargetCategories: DB.EnumCase({
             type: DB.IncludeIdentifier(TargetCategoriesSelectOptionCategory),
         }),
+        Advantages: DB.EnumCase({
+            type: DB.IncludeIdentifier(AdvantagesSelectOptionCategory),
+        }),
     }),
 });
 export const TradeSecretSelectOptionCategory = DB.Enum(import.meta.url, {
@@ -504,3 +507,12 @@ const SpecificTargetCategory = DB.TypeAlias(import.meta.url, {
         }),
     }),
 });
+const AdvantagesSelectOptionCategory = DB.TypeAlias(import.meta.url, {
+    name: "AdvantagesSelectOptionCategory",
+    type: () => DB.Object({
+        dependingOn: DB.Required({
+            comment: "A list of advantages of which the generated advantages must depend on at least one of them each.",
+            type: DB.Array(AdvantageIdentifier(), { minItems: 1, uniqueItems: true }),
+        }),
+    }),
+});

package/lib/types/_ActivatableSelectOptions.d.ts

@@ -833,6 +833,9 @@ declare const SelectOptions: DB.TypeAlias<"SelectOptions", DB.Object<{
                 volume: DB.MemberDecl<DB.Integer, false>;
             }>, []>>>, true>;
         }>, []>>>;
+        Advantages: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdvantagesSelectOptionCategory", DB.Object<{
+            dependingOn: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+        }>, []>>>;
     }, []>>, false>;
     rules: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectOptionRules", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectOptionRule", DB.Object<{
         value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionRuleValue", {
@@ -1696,6 +1699,9 @@ export declare const select_options: DB.MemberDecl<DB.IncludeIdentifier<[], DB.T
                 volume: DB.MemberDecl<DB.Integer, false>;
             }>, []>>>, true>;
         }>, []>>>;
+        Advantages: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdvantagesSelectOptionCategory", DB.Object<{
+            dependingOn: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+        }>, []>>>;
     }, []>>, false>;
     rules: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectOptionRules", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectOptionRule", DB.Object<{
         value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionRuleValue", {

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

@@ -22,6 +22,78 @@ export declare const Ammunition: DB.Entity<"Ammunition", {
             }>, false>;
         }>, []>>>;
     }, []>>, true>;
+    complexity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Complexity", {
+        Primitive: DB.EnumCase<null>;
+        Simple: DB.EnumCase<null>;
+        Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
+            ap_value: DB.MemberDecl<DB.Integer, true>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", 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, {
+                    initial: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"InitialOccurrence", DB.Object<{
+                        printing: DB.MemberDecl<DB.Integer, false>;
+                        pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                            first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                                InsideCoverFront: DB.EnumCase<null>;
+                                InsideCoverBack: DB.EnumCase<null>;
+                                Numbered: DB.EnumCase<DB.Integer>;
+                            }, []>>, true>;
+                            last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                                InsideCoverFront: DB.EnumCase<null>;
+                                InsideCoverBack: DB.EnumCase<null>;
+                                Numbered: DB.EnumCase<DB.Integer>;
+                            }, []>>, false>;
+                        }>, []>>>, true>;
+                        isRemoved: DB.MemberDecl<DB.Boolean, false>;
+                    }>, []>>, true>;
+                    revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
+                        Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
+                            printing: DB.MemberDecl<DB.Integer, true>;
+                            pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                                first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                                    InsideCoverFront: DB.EnumCase<null>;
+                                    InsideCoverBack: DB.EnumCase<null>;
+                                    Numbered: DB.EnumCase<DB.Integer>;
+                                }, []>>, true>;
+                                last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                                    InsideCoverFront: DB.EnumCase<null>;
+                                    InsideCoverBack: DB.EnumCase<null>;
+                                    Numbered: DB.EnumCase<DB.Integer>;
+                                }, []>>, false>;
+                            }>, []>>>, true>;
+                        }>, []>>>;
+                        Deprecated: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Deprecation", DB.Object<{
+                            printing: DB.MemberDecl<DB.Integer, true>;
+                        }>, []>>>;
+                    }, []>>>, false>;
+                }>, true>;
+            }>, []>>>, []>>, false>;
+        }>, []>>>;
+    }, []>>, 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/Ammunition.js

@@ -2,7 +2,7 @@ import * as DB from "tsondb/schema/dsl";
 import { NestedTranslationMap } from "../../Locale.js";
 import { Errata } from "../../source/_Erratum.js";
 import { src } from "../../source/_PublicationRef.js";
-import { Cost } from "./_Item.js";
+import { Complexity, Cost } from "./_Item.js";
 export const Ammunition = DB.Entity(import.meta.url, {
     name: "Ammunition",
     namePlural: "Ammunitions",
@@ -11,6 +11,10 @@ export const Ammunition = DB.Entity(import.meta.url, {
             comment: "The cost in silverthalers.",
             type: DB.IncludeIdentifier(Cost),
         }),
+        complexity: DB.Optional({
+            comment: "The complexity of crafting the item.",
+            type: DB.IncludeIdentifier(Complexity),
+        }),
         src,
         translations: NestedTranslationMap(DB.Required, "Ammunition", DB.Object({
             name: DB.Required({

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

@@ -28,6 +28,30 @@ export declare const Armor: DB.Entity<"Armor", {
         Simple: DB.EnumCase<null>;
         Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
             ap_value: DB.MemberDecl<DB.Integer, true>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", 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/BandageOrRemedy.d.ts

@@ -28,6 +28,30 @@ export declare const BandageOrRemedy: DB.Entity<"BandageOrRemedy", {
         Simple: DB.EnumCase<null>;
         Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
             ap_value: DB.MemberDecl<DB.Integer, true>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", 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/Book.d.ts

@@ -91,6 +91,30 @@ export declare const Book: DB.Entity<"Book", {
         Simple: DB.EnumCase<null>;
         Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
             ap_value: DB.MemberDecl<DB.Integer, true>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", 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/CeremonialItem.d.ts

@@ -28,6 +28,30 @@ export declare const CeremonialItem: DB.Entity<"CeremonialItem", {
         Simple: DB.EnumCase<null>;
         Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
             ap_value: DB.MemberDecl<DB.Integer, true>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", 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/Clothes.d.ts

@@ -28,6 +28,30 @@ export declare const Clothes: DB.Entity<"Clothes", {
         Simple: DB.EnumCase<null>;
         Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
             ap_value: DB.MemberDecl<DB.Integer, true>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", 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/Container.d.ts

@@ -28,6 +28,30 @@ export declare const Container: DB.Entity<"Container", {
         Simple: DB.EnumCase<null>;
         Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
             ap_value: DB.MemberDecl<DB.Integer, true>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", 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/IlluminationLightSource.d.ts

@@ -28,6 +28,30 @@ export declare const IlluminationLightSource: DB.Entity<"IlluminationLightSource
         Simple: DB.EnumCase<null>;
         Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
             ap_value: DB.MemberDecl<DB.Integer, true>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", 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/IlluminationRefillOrSupply.d.ts

@@ -28,6 +28,30 @@ export declare const IlluminationRefillOrSupply: DB.Entity<"IlluminationRefillOr
         Simple: DB.EnumCase<null>;
         Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
             ap_value: DB.MemberDecl<DB.Integer, true>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", 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.d.ts

@@ -29,6 +29,30 @@ export declare const Item: DB.Entity<"Item", {
         Simple: DB.EnumCase<null>;
         Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
             ap_value: DB.MemberDecl<DB.Integer, true>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", 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, {