@optolith/database-schema 0.98.0 → 0.100.0

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

@@ -0,0 +1,127 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const ItemComponent: DB.Entity<"ItemComponent", {
+    options: DB.MemberDecl<DB.ChildEntities<DB.Entity<"ItemComponentOption", {
+        parent: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        cost: DB.MemberDecl<DB.Float, true>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"ItemComponentOptionTranslation", {
+            label: DB.MemberDecl<DB.String, true>;
+        }>, true>;
+    }, "parent">>, true>;
+    cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ItemComponentCost", {
+        Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
+            value: DB.MemberDecl<DB.Float, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
+        ByCombatTechnique: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ItemComponentCostByCombatTechnique", DB.Object<{
+            close: DB.MemberDecl<DB.NestedEntityMap<string, {
+                value: DB.MemberDecl<DB.Float, true>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"ItemComponentCostByCloseCombatTechniqueTranslation", {
+                    label: DB.MemberDecl<DB.String, true>;
+                }>, false>;
+            }>, false>;
+            ranged: DB.MemberDecl<DB.NestedEntityMap<string, {
+                value: DB.MemberDecl<DB.Float, true>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"ItemComponentCostByRangedCombatTechniqueTranslation", {
+                    label: DB.MemberDecl<DB.String, true>;
+                }>, false>;
+            }>, false>;
+        }>, []>>>;
+        Factor: DB.EnumCase<DB.Float>;
+        DerivedFromOption: DB.EnumCase<null>;
+    }, []>>, true>;
+    applicableItems: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableItems", {
+        MeleeWeapon: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableMeleeWeapons", DB.Object<{
+            weapons: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
+            combatTechniques: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
+            category: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableMeleeWeaponCategory", {
+                HasMetalSurface: DB.EnumCase<null>;
+                HasMetalBladeOrTip: DB.EnumCase<null>;
+            }, []>>, false>;
+        }>, []>>>;
+        RangedWeapon: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableRangedWeapons", DB.Object<{
+            weapons: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
+            combatTechniques: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
+            minimumReloadTime: DB.MemberDecl<DB.Integer, false>;
+            usesBullets: DB.MemberDecl<DB.Boolean, false>;
+        }>, []>>>;
+        Ammunition: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableAmmunition", DB.Object<{
+            ammunition: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
+            invertAmmunition: DB.MemberDecl<DB.Boolean, false>;
+            category: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableAmmunitionCategory", {
+                ArrowOrBolt: DB.EnumCase<null>;
+            }, []>>, false>;
+        }>, []>>>;
+        Armor: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableArmor", DB.Object<{
+            armor: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
+            category: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableArmorCategory", {
+                Metal: DB.EnumCase<null>;
+            }, []>>, false>;
+        }>, []>>>;
+    }, []>>, true>;
+    incompatibleWith: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
+    rules: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ItemComponentRules", DB.Object<{
+        baseItemModifications: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ItemComponentBaseItemModifications", DB.Object<{
+            damagePoints: DB.MemberDecl<DB.Integer, false>;
+            attackModifier: DB.MemberDecl<DB.Integer, false>;
+            parryModifier: DB.MemberDecl<DB.Integer, false>;
+            protection: DB.MemberDecl<DB.Integer, false>;
+            encumbrance: DB.MemberDecl<DB.Integer, false>;
+            range: DB.MemberDecl<DB.Integer, false>;
+            reloadTime: DB.MemberDecl<DB.Integer, false>;
+            weight: DB.MemberDecl<DB.Float, false>;
+            breakingPointRating: DB.MemberDecl<DB.Integer, false>;
+        }>, []>>, 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, {
+            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>;
+    }>, []>>>, []>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"ItemComponentTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        rules: DB.MemberDecl<DB.String, false>;
+        applicableItems: DB.MemberDecl<DB.String, false>;
+        errata: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Errata", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Erratum", DB.Object<{
+            date: DB.MemberDecl<DB.Date, true>;
+            description: DB.MemberDecl<DB.String, true>;
+        }>, []>>>, []>>, false>;
+    }>, true>;
+}, undefined>;

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

@@ -0,0 +1,313 @@
+import * as DB from "tsondb/schema/dsl";
+import { AmmunitionIdentifier, ArmorIdentifier, CloseCombatTechniqueIdentifier, ItemComponentIdentifier, RangedCombatTechniqueIdentifier, WeaponIdentifier, } from "../../_Identifier.js";
+import { CloseCombatTechnique, RangedCombatTechnique } from "../../CombatTechnique.js";
+import { NestedTranslationMap } from "../../Locale.js";
+import { Errata } from "../../source/_Erratum.js";
+import { src } from "../../source/_PublicationRef.js";
+import { FixedCost } from "./_Item.js";
+export const ItemComponent = DB.Entity(import.meta.url, {
+    name: "ItemComponent",
+    namePlural: "ItemComponents",
+    type: () => DB.Object({
+        options: DB.Required({
+            type: DB.ChildEntities(ItemComponentOption),
+        }),
+        cost: DB.Required({
+            comment: ItemComponentCost.comment,
+            type: DB.IncludeIdentifier(ItemComponentCost),
+        }),
+        applicableItems: DB.Required({
+            comment: "The items the component can be applied to.",
+            type: DB.IncludeIdentifier(ApplicableItems),
+        }),
+        incompatibleWith: DB.Optional({
+            comment: "Other components this component is not compatible with.",
+            type: DB.Array(ItemComponentIdentifier(), {
+                minItems: 1,
+                uniqueItems: true,
+            }),
+        }),
+        rules: DB.Optional({
+            comment: "Special rules for the item component.",
+            type: DB.IncludeIdentifier(ItemComponentRules),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "ItemComponent", DB.Object({
+            name: DB.Required({
+                comment: "The item’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            rules: DB.Optional({
+                comment: "Special rules text.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            applicableItems: DB.Optional({
+                comment: "The items the component can be applied to. Used if the generated text is not sufficient.",
+                type: DB.String({ minLength: 1, markdown: "inline" }),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});
+const ItemComponentOption = DB.Entity(import.meta.url, {
+    name: "ItemComponentOption",
+    namePlural: "ItemComponentOptions",
+    type: () => DB.Object({
+        parent: DB.Required({
+            comment: "The item component this option belongs to.",
+            type: ItemComponentIdentifier(),
+        }),
+        cost: DB.Required({
+            comment: "The cost in silverthalers.",
+            type: DB.Float({ minimum: { value: 0, isExclusive: true } }),
+        }),
+        translations: NestedTranslationMap(DB.Required, "ItemComponentOption", DB.Object({
+            label: DB.Required({
+                comment: "The label for the option.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    instanceDisplayName: { pathInLocaleMap: "label" },
+    parentReferenceKey: "parent",
+});
+const ItemComponentCost = DB.Enum(import.meta.url, {
+    name: "ItemComponentCost",
+    comment: "The cost in silverthalers.",
+    values: () => ({
+        Fixed: DB.EnumCase({
+            comment: "The cost is a fixed amount of silverthalers.",
+            type: DB.IncludeIdentifier(FixedCost),
+        }),
+        ByCombatTechnique: DB.EnumCase({
+            comment: "The cost depends on the combat technique of the item it is applied to.",
+            type: DB.IncludeIdentifier(ItemComponentCostByCombatTechnique),
+        }),
+        Factor: DB.EnumCase({
+            comment: "The cost is a percentage of the cost of the item it is applied to.",
+            type: DB.Float({ minimum: { value: 0, isExclusive: true } }),
+        }),
+        DerivedFromOption: DB.EnumCase({
+            comment: "The cost depends on the selected option.",
+            type: null,
+        }),
+    }),
+});
+const ItemComponentCostByCombatTechnique = DB.TypeAlias(import.meta.url, {
+    name: "ItemComponentCostByCombatTechnique",
+    type: () => DB.Object({
+        close: DB.Optional({
+            comment: "The cost in silverthalers for close combat techniques.",
+            type: DB.NestedEntityMap({
+                name: "ItemComponentCostByCloseCombatTechnique",
+                namePlural: "ItemComponentCostsByCloseCombatTechnique",
+                secondaryEntity: CloseCombatTechnique,
+                type: DB.Object({
+                    value: DB.Required({
+                        comment: "The cost in silverthalers for the close combat technique.",
+                        type: DB.Float({ minimum: { value: 0, isExclusive: true } }),
+                    }),
+                    translations: NestedTranslationMap(DB.Optional, "ItemComponentCostByCloseCombatTechnique", DB.Object({
+                        label: DB.Required({
+                            comment: "The label for cost, if different from the name of the combat technique.",
+                            type: DB.String({ minLength: 1 }),
+                        }),
+                    })),
+                }),
+            }),
+        }),
+        ranged: DB.Optional({
+            comment: "The cost in silverthalers for ranged combat techniques.",
+            type: DB.NestedEntityMap({
+                name: "ItemComponentCostByRangedCombatTechnique",
+                namePlural: "ItemComponentCostsByRangedCombatTechnique",
+                secondaryEntity: RangedCombatTechnique,
+                type: DB.Object({
+                    value: DB.Required({
+                        comment: "The cost in silverthalers for the ranged combat technique.",
+                        type: DB.Float({ minimum: { value: 0, isExclusive: true } }),
+                    }),
+                    translations: NestedTranslationMap(DB.Optional, "ItemComponentCostByRangedCombatTechnique", DB.Object({
+                        label: DB.Required({
+                            comment: "The label for cost, if different from the name of the combat technique.",
+                            type: DB.String({ minLength: 1 }),
+                        }),
+                    })),
+                }),
+            }),
+        }),
+    }, { minProperties: 1 }),
+});
+const ApplicableItems = DB.Enum(import.meta.url, {
+    name: "ApplicableItems",
+    comment: "The items the component can be applied to.",
+    values: () => ({
+        MeleeWeapon: DB.EnumCase({ type: DB.IncludeIdentifier(ApplicableMeleeWeapons) }),
+        RangedWeapon: DB.EnumCase({ type: DB.IncludeIdentifier(ApplicableRangedWeapons) }),
+        Ammunition: DB.EnumCase({ type: DB.IncludeIdentifier(ApplicableAmmunition) }),
+        Armor: DB.EnumCase({ type: DB.IncludeIdentifier(ApplicableArmor) }),
+    }),
+});
+const ApplicableMeleeWeapons = DB.TypeAlias(import.meta.url, {
+    name: "ApplicableMeleeWeapons",
+    type: () => DB.Object({
+        weapons: DB.Optional({
+            comment: "Specific weapons this component can be applied to.",
+            type: DB.Array(WeaponIdentifier(), {
+                minItems: 1,
+                uniqueItems: true,
+            }),
+        }),
+        combatTechniques: DB.Optional({
+            comment: "Weapons of combat techniques this component can be applied to.",
+            type: DB.Array(CloseCombatTechniqueIdentifier(), {
+                minItems: 1,
+                uniqueItems: true,
+            }),
+        }),
+        category: DB.Optional({
+            comment: "The category of weapons this component can be applied to.",
+            type: DB.IncludeIdentifier(ApplicableMeleeWeaponCategory),
+        }),
+    }, { minProperties: 1 }),
+});
+const ApplicableMeleeWeaponCategory = DB.Enum(import.meta.url, {
+    name: "ApplicableMeleeWeaponCategory",
+    values: () => ({
+        HasMetalSurface: DB.EnumCase({ type: null }),
+        HasMetalBladeOrTip: DB.EnumCase({ type: null }),
+    }),
+});
+const ApplicableRangedWeapons = DB.TypeAlias(import.meta.url, {
+    name: "ApplicableRangedWeapons",
+    type: () => DB.Object({
+        weapons: DB.Optional({
+            comment: "Specific weapons this component can be applied to.",
+            type: DB.Array(WeaponIdentifier(), {
+                minItems: 1,
+                uniqueItems: true,
+            }),
+        }),
+        combatTechniques: DB.Optional({
+            comment: "Weapons of combat techniques this component can be applied to.",
+            type: DB.Array(RangedCombatTechniqueIdentifier(), {
+                minItems: 1,
+                uniqueItems: true,
+            }),
+        }),
+        minimumReloadTime: DB.Optional({
+            comment: "The minimum reload time a crossbow must have for it to be compatible with this component.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        usesBullets: DB.Optional({
+            comment: "Whether the crossbow must use bullets to be compatible with this component.",
+            type: DB.Boolean(),
+        }),
+    }, { minProperties: 1 }),
+});
+const ApplicableAmmunition = DB.TypeAlias(import.meta.url, {
+    name: "ApplicableAmmunition",
+    type: () => DB.Object({
+        ammunition: DB.Optional({
+            comment: "Specific ammunition this component can be applied to.",
+            type: DB.Array(AmmunitionIdentifier(), {
+                minItems: 1,
+                uniqueItems: true,
+            }),
+        }),
+        invertAmmunition: DB.Optional({
+            comment: "Whether the list of ammunition is inverted, i.e. whether the component can be applied to all ammunition – or those of the specified category – except for the listed ammunition.",
+            type: DB.Boolean(),
+        }),
+        category: DB.Optional({
+            comment: "The category of weapons this component can be applied to.",
+            type: DB.IncludeIdentifier(ApplicableAmmunitionCategory),
+        }),
+    }, { minProperties: 1 }),
+});
+const ApplicableAmmunitionCategory = DB.Enum(import.meta.url, {
+    name: "ApplicableAmmunitionCategory",
+    values: () => ({
+        ArrowOrBolt: DB.EnumCase({ type: null }),
+    }),
+});
+const ApplicableArmor = DB.TypeAlias(import.meta.url, {
+    name: "ApplicableArmor",
+    type: () => DB.Object({
+        armor: DB.Optional({
+            comment: "Specific armor this component can be applied to.",
+            type: DB.Array(ArmorIdentifier(), {
+                minItems: 1,
+                uniqueItems: true,
+            }),
+        }),
+        category: DB.Optional({
+            comment: "The category of weapons this component can be applied to.",
+            type: DB.IncludeIdentifier(ApplicableArmorCategory),
+        }),
+    }),
+});
+const ApplicableArmorCategory = DB.Enum(import.meta.url, {
+    name: "ApplicableArmorCategory",
+    values: () => ({
+        Metal: DB.EnumCase({ type: null }),
+    }),
+});
+const ItemComponentRules = DB.TypeAlias(import.meta.url, {
+    name: "ItemComponentRules",
+    type: () => DB.Object({
+        baseItemModifications: DB.Optional({
+            type: DB.IncludeIdentifier(ItemComponentBaseItemModifications),
+        }),
+    }, { minProperties: 1 }),
+});
+const ItemComponentBaseItemModifications = DB.TypeAlias(import.meta.url, {
+    name: "ItemComponentBaseItemModifications",
+    type: () => DB.Object({
+        damagePoints: DB.Optional({
+            comment: "The damage points added to the damage points of the base item. Negative values lower the damage points.",
+            type: DB.Integer(),
+        }),
+        attackModifier: DB.Optional({
+            comment: "The attack modifier added to the attack modifier of the base item. Negative values lower the attack modifier.",
+            type: DB.Integer(),
+        }),
+        parryModifier: DB.Optional({
+            comment: "The parry modifier added to the parry modifier of the base item. Negative values lower the parry modifier.",
+            type: DB.Integer(),
+        }),
+        protection: DB.Optional({
+            comment: "The protection added to the protection of the base item. Negative values lower the protection.",
+            type: DB.Integer(),
+        }),
+        encumbrance: DB.Optional({
+            comment: "The encumbrance added to the encumbrance of the base item. Negative values lower the encumbrance.",
+            type: DB.Integer(),
+        }),
+        range: DB.Optional({
+            comment: "The range added to the range of the base item. Negative values lower the range.",
+            type: DB.Integer(),
+        }),
+        reloadTime: DB.Optional({
+            comment: "The reload time added to the reload time of the base item. Negative values lower the reload time.",
+            type: DB.Integer(),
+        }),
+        weight: DB.Optional({
+            comment: "The weight added to the weight of the base item. Negative values lower the weight.",
+            type: DB.Float(),
+        }),
+        breakingPointRating: DB.Optional({
+            comment: "The breaking point rating added to the breaking point rating of the base item. Negative values lower the breaking point rating.",
+            type: DB.Integer(),
+        }),
+    }, { minProperties: 1 }),
+});

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

@@ -177,7 +177,9 @@ export declare const Liebesspielzeug: DB.Entity<"Liebesspielzeug", {
                     }, []>>, true>;
                     isSanctifiedBy: DB.MemberDecl<DB.Boolean, true>;
                     translations: DB.MemberDecl<DB.NestedEntityMap<"RestrictedToBlessedTraditionsTranslation", {
+                        sanctified: DB.MemberDecl<DB.String, false>;
                         item: DB.MemberDecl<DB.String, true>;
+                        blessedOnes: DB.MemberDecl<DB.String, false>;
                     }>, true>;
                 }>, []>>, false>;
             }>, []>>, false>;
@@ -193,13 +195,22 @@ export declare const Liebesspielzeug: DB.Entity<"Liebesspielzeug", {
             armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
                 Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
                     sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"StandardArmorTypeTranslation", {
+                        nameInNote: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
                 }>, []>>>;
                 StandardVariant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardVariantArmorType", DB.Object<{
                     variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
                     sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"StandardVariantArmorTypeTranslation", {
+                        nameInNote: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
                 }>, []>>>;
                 Variant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VariantArmorType", DB.Object<{
                     variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"VariantArmorTypeTranslation", {
+                        nameInNote: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
                 }>, []>>>;
             }, []>>, true>;
             hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
@@ -245,7 +256,9 @@ export declare const Liebesspielzeug: DB.Entity<"Liebesspielzeug", {
                     }, []>>, true>;
                     isSanctifiedBy: DB.MemberDecl<DB.Boolean, true>;
                     translations: DB.MemberDecl<DB.NestedEntityMap<"RestrictedToBlessedTraditionsTranslation", {
+                        sanctified: DB.MemberDecl<DB.String, false>;
                         item: DB.MemberDecl<DB.String, true>;
+                        blessedOnes: DB.MemberDecl<DB.String, false>;
                     }>, true>;
                 }>, []>>, false>;
             }>, []>>, false>;

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

@@ -177,7 +177,9 @@ export declare const LuxuryGood: DB.Entity<"LuxuryGood", {
                     }, []>>, true>;
                     isSanctifiedBy: DB.MemberDecl<DB.Boolean, true>;
                     translations: DB.MemberDecl<DB.NestedEntityMap<"RestrictedToBlessedTraditionsTranslation", {
+                        sanctified: DB.MemberDecl<DB.String, false>;
                         item: DB.MemberDecl<DB.String, true>;
+                        blessedOnes: DB.MemberDecl<DB.String, false>;
                     }>, true>;
                 }>, []>>, false>;
             }>, []>>, false>;
@@ -193,13 +195,22 @@ export declare const LuxuryGood: DB.Entity<"LuxuryGood", {
             armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
                 Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
                     sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"StandardArmorTypeTranslation", {
+                        nameInNote: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
                 }>, []>>>;
                 StandardVariant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardVariantArmorType", DB.Object<{
                     variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
                     sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"StandardVariantArmorTypeTranslation", {
+                        nameInNote: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
                 }>, []>>>;
                 Variant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VariantArmorType", DB.Object<{
                     variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"VariantArmorTypeTranslation", {
+                        nameInNote: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
                 }>, []>>>;
             }, []>>, true>;
             hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
@@ -245,7 +256,9 @@ export declare const LuxuryGood: DB.Entity<"LuxuryGood", {
                     }, []>>, true>;
                     isSanctifiedBy: DB.MemberDecl<DB.Boolean, true>;
                     translations: DB.MemberDecl<DB.NestedEntityMap<"RestrictedToBlessedTraditionsTranslation", {
+                        sanctified: DB.MemberDecl<DB.String, false>;
                         item: DB.MemberDecl<DB.String, true>;
+                        blessedOnes: DB.MemberDecl<DB.String, false>;
                     }>, true>;
                 }>, []>>, false>;
             }>, []>>, false>;

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

@@ -177,7 +177,9 @@ export declare const MagicalArtifact: DB.Entity<"MagicalArtifact", {
                     }, []>>, true>;
                     isSanctifiedBy: DB.MemberDecl<DB.Boolean, true>;
                     translations: DB.MemberDecl<DB.NestedEntityMap<"RestrictedToBlessedTraditionsTranslation", {
+                        sanctified: DB.MemberDecl<DB.String, false>;
                         item: DB.MemberDecl<DB.String, true>;
+                        blessedOnes: DB.MemberDecl<DB.String, false>;
                     }>, true>;
                 }>, []>>, false>;
             }>, []>>, false>;
@@ -193,13 +195,22 @@ export declare const MagicalArtifact: DB.Entity<"MagicalArtifact", {
             armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
                 Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
                     sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"StandardArmorTypeTranslation", {
+                        nameInNote: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
                 }>, []>>>;
                 StandardVariant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardVariantArmorType", DB.Object<{
                     variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
                     sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"StandardVariantArmorTypeTranslation", {
+                        nameInNote: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
                 }>, []>>>;
                 Variant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VariantArmorType", DB.Object<{
                     variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"VariantArmorTypeTranslation", {
+                        nameInNote: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
                 }>, []>>>;
             }, []>>, true>;
             hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
@@ -245,7 +256,9 @@ export declare const MagicalArtifact: DB.Entity<"MagicalArtifact", {
                     }, []>>, true>;
                     isSanctifiedBy: DB.MemberDecl<DB.Boolean, true>;
                     translations: DB.MemberDecl<DB.NestedEntityMap<"RestrictedToBlessedTraditionsTranslation", {
+                        sanctified: DB.MemberDecl<DB.String, false>;
                         item: DB.MemberDecl<DB.String, true>;
+                        blessedOnes: DB.MemberDecl<DB.String, false>;
                     }>, true>;
                 }>, []>>, false>;
             }>, []>>, false>;

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

@@ -177,7 +177,9 @@ export declare const MusicalInstrument: DB.Entity<"MusicalInstrument", {
                     }, []>>, true>;
                     isSanctifiedBy: DB.MemberDecl<DB.Boolean, true>;
                     translations: DB.MemberDecl<DB.NestedEntityMap<"RestrictedToBlessedTraditionsTranslation", {
+                        sanctified: DB.MemberDecl<DB.String, false>;
                         item: DB.MemberDecl<DB.String, true>;
+                        blessedOnes: DB.MemberDecl<DB.String, false>;
                     }>, true>;
                 }>, []>>, false>;
             }>, []>>, false>;
@@ -193,13 +195,22 @@ export declare const MusicalInstrument: DB.Entity<"MusicalInstrument", {
             armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
                 Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
                     sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"StandardArmorTypeTranslation", {
+                        nameInNote: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
                 }>, []>>>;
                 StandardVariant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardVariantArmorType", DB.Object<{
                     variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
                     sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"StandardVariantArmorTypeTranslation", {
+                        nameInNote: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
                 }>, []>>>;
                 Variant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VariantArmorType", DB.Object<{
                     variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"VariantArmorTypeTranslation", {
+                        nameInNote: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
                 }>, []>>>;
             }, []>>, true>;
             hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
@@ -245,7 +256,9 @@ export declare const MusicalInstrument: DB.Entity<"MusicalInstrument", {
                     }, []>>, true>;
                     isSanctifiedBy: DB.MemberDecl<DB.Boolean, true>;
                     translations: DB.MemberDecl<DB.NestedEntityMap<"RestrictedToBlessedTraditionsTranslation", {
+                        sanctified: DB.MemberDecl<DB.String, false>;
                         item: DB.MemberDecl<DB.String, true>;
+                        blessedOnes: DB.MemberDecl<DB.String, false>;
                     }>, true>;
                 }>, []>>, false>;
             }>, []>>, false>;