@optolith/database-schema 0.42.1

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

@@ -0,0 +1,201 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const WeaponAccessory: DB.Entity<"WeaponAccessory", {
+    cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
+        Free: DB.EnumCase<null>;
+        Various: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<null>;
+        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>;
+        }>, []>>>;
+        Range: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CostRange", DB.Object<{
+            from: DB.MemberDecl<DB.Float, true>;
+            to: DB.MemberDecl<DB.Float, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"CostRangeTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
+    }, []>>, true>;
+    weight: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Weight", DB.Float, []>>, false>;
+    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>;
+        }>, []>>>;
+    }, []>>, false>;
+    structure_points: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
+        points: DB.MemberDecl<DB.Integer, true>;
+    }>, []>>>, []>>, false>;
+    combat_use: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CombatUse", {
+        Weapon: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ImprovisedWeapon", DB.Object<{
+            melee_uses: DB.MemberDecl<DB.NestedEntityMap<string, {
+                damage: DB.MemberDecl<DB.TypeArgument<DB.Param<"Damage", DB.Type>>, true>;
+                damage_threshold: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"PrimaryAttributeDamageThreshold", {
+                    Default: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DefaultPrimaryAttributeDamageThreshold", DB.Object<{
+                        threshold: DB.MemberDecl<DB.Integer, true>;
+                    }>, []>>>;
+                    List: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PrimaryAttributeDamageThresholdList", DB.Object<{
+                        list: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SinglePrimaryAttributeDamageThreshold", DB.Object<{
+                            attribute: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                            threshold: DB.MemberDecl<DB.Integer, true>;
+                        }>, []>>>, true>;
+                    }>, []>>>;
+                }, []>>, false>;
+                attackModifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AttackModifier", DB.Integer, []>>, false>;
+                parryModifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ParryModifier", DB.Integer, []>>, false>;
+                reach: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
+                length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Length", DB.Integer, []>>, false>;
+                size: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ShieldSize", {
+                    Small: DB.EnumCase<null>;
+                    Medium: DB.EnumCase<null>;
+                    Large: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"LargeShieldSize", DB.Object<{
+                        attack_penalty: DB.MemberDecl<DB.Integer, false>;
+                    }>, []>>>;
+                }, []>>, false>;
+                is_parrying_weapon: DB.MemberDecl<DB.Boolean, true>;
+                is_two_handed_weapon: DB.MemberDecl<DB.Boolean, true>;
+                is_improvised_weapon: DB.MemberDecl<DB.Boolean, true>;
+            }>, false>;
+            ranged_uses: DB.MemberDecl<DB.NestedEntityMap<string, {
+                damage: DB.MemberDecl<DB.TypeArgument<DB.Param<"Damage", DB.Type>>, true>;
+                reload_time: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ReloadTime", DB.Object<{
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>, true>;
+                range: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RangeBrackets", DB.Object<{
+                    close: DB.MemberDecl<DB.Integer, true>;
+                    medium: DB.MemberDecl<DB.Integer, true>;
+                    far: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>, true>;
+                ammunition: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"AmmunitionishIdentifier", {
+                    Ammunition: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Weapon: DB.EnumCase<DB.ReferenceIdentifier>;
+                }, []>>, false>;
+                length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Length", DB.Integer, []>>, false>;
+                is_improvised_weapon: DB.MemberDecl<DB.Boolean, true>;
+            }>, false>;
+            restrictedTo: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedTo", DB.Object<{
+                races: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToRaces", DB.Object<{
+                    scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+                }>, []>>, false>;
+                cultures: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToCultures", DB.Object<{
+                    scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+                }>, []>>, false>;
+                professions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToProfessions", DB.Object<{
+                    scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+                }>, []>>, false>;
+                magicalTraditions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToMagicalTraditions", DB.Object<{
+                    scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+                }>, []>>, false>;
+                blessedTraditions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToBlessedTraditions", DB.Object<{
+                    scope: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RestrictedToBlessedTraditionsScope", {
+                        Specific: DB.EnumCase<DB.Array<DB.ReferenceIdentifier>>;
+                        Church: DB.EnumCase<null>;
+                        Shamanistic: DB.EnumCase<null>;
+                    }, []>>, true>;
+                    isSanctifiedBy: DB.MemberDecl<DB.Boolean, true>;
+                }>, []>>, false>;
+            }>, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ImprovisedWeaponTranslation", {
+                advantage: DB.MemberDecl<DB.String, false>;
+                disadvantage: DB.MemberDecl<DB.String, false>;
+            }>, false>;
+        }>, []>>>;
+        Armor: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SecondaryArmor", DB.Object<{
+            protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
+            encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
+            armor_type: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
+                Head: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZone", DB.Object<{
+                    combination_possibilities: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZoneCombinationPossibilities", DB.Object<{
+                        armors: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+                        protection: DB.MemberDecl<DB.Integer, false>;
+                    }>, []>>, false>;
+                }>, []>>>;
+                Torso: DB.EnumCase<null>;
+                Arms: DB.EnumCase<null>;
+                Legs: DB.EnumCase<null>;
+            }, []>>, false>;
+            restrictedTo: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedTo", DB.Object<{
+                races: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToRaces", DB.Object<{
+                    scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+                }>, []>>, false>;
+                cultures: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToCultures", DB.Object<{
+                    scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+                }>, []>>, false>;
+                professions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToProfessions", DB.Object<{
+                    scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+                }>, []>>, false>;
+                magicalTraditions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToMagicalTraditions", DB.Object<{
+                    scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+                }>, []>>, false>;
+                blessedTraditions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToBlessedTraditions", DB.Object<{
+                    scope: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RestrictedToBlessedTraditionsScope", {
+                        Specific: DB.EnumCase<DB.Array<DB.ReferenceIdentifier>>;
+                        Church: DB.EnumCase<null>;
+                        Shamanistic: DB.EnumCase<null>;
+                    }, []>>, true>;
+                    isSanctifiedBy: DB.MemberDecl<DB.Boolean, true>;
+                }>, []>>, false>;
+            }>, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"SecondaryArmorTranslation", {
+                advantage: DB.MemberDecl<DB.String, false>;
+                disadvantage: DB.MemberDecl<DB.String, 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<`${string}Translation`, {
+        name: DB.MemberDecl<DB.String, true>;
+        secondary_name: DB.MemberDecl<DB.String, false>;
+        note: DB.MemberDecl<DB.String, false>;
+        rules: 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/WeaponAccessory.js

@@ -0,0 +1,48 @@
+import * as DB from "tsondb/schema/dsl";
+import { src } from "../../source/_PublicationRef.js";
+import { CombatUse, Complexity, Cost, DefaultItemTranslations, StructurePoints, Weight, } from "./_Item.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
+export const WeaponAccessory = DB.Entity(import.meta.url, {
+    name: "WeaponAccessory",
+    namePlural: "WeaponAccessories",
+    type: () => DB.Object({
+        cost: DB.Required({
+            comment: "The cost in silverthalers.",
+            type: DB.IncludeIdentifier(Cost),
+        }),
+        weight: DB.Optional({
+            comment: "The weight in kg.",
+            type: DB.IncludeIdentifier(Weight),
+        }),
+        complexity: DB.Optional({
+            comment: "The complexity of crafting the item.",
+            type: DB.IncludeIdentifier(Complexity),
+        }),
+        structure_points: DB.Optional({
+            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),
+        }),
+        combat_use: DB.Optional({
+            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),
+        }),
+        src,
+        translations: DefaultItemTranslations("WeaponAccessory"),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+    customConstraints: ({ instanceContent, ...rest }) => {
+        if (instanceContent.combat_use && instanceContent.combat_use.kind === "Weapon") {
+            return checkWeaponCombatTechniqueIntegrity({
+                ...rest,
+                instanceContent: instanceContent.combat_use.Weapon,
+            }, { secondary: true });
+        }
+        return [];
+    },
+});

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

@@ -0,0 +1,72 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const WorkingSupernaturalCreature: DB.Entity<"WorkingSupernaturalCreature", {
+    cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
+        Free: DB.EnumCase<null>;
+        Various: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<null>;
+        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>;
+        }>, []>>>;
+        Range: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CostRange", DB.Object<{
+            from: DB.MemberDecl<DB.Float, true>;
+            to: DB.MemberDecl<DB.Float, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"CostRangeTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
+    }, []>>, true>;
+    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<"WorkingSupernaturalCreatureTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        appearance: DB.MemberDecl<DB.String, true>;
+        components: DB.MemberDecl<DB.String, true>;
+        use: DB.MemberDecl<DB.String, true>;
+        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/WorkingSupernaturalCreature.js

@@ -0,0 +1,44 @@
+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";
+export const WorkingSupernaturalCreature = DB.Entity(import.meta.url, {
+    name: "WorkingSupernaturalCreature",
+    namePlural: "WorkingSupernaturalCreatures",
+    type: () => DB.Object({
+        cost: DB.Required({
+            comment: "The cost in silverthalers.",
+            type: DB.IncludeIdentifier(Cost),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "WorkingSupernaturalCreature", DB.Object({
+            name: DB.Required({
+                comment: "The working creature’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            appearance: DB.Required({
+                comment: "The working creature’s appearance.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            components: DB.Required({
+                comment: "The working creature’s components.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            use: DB.Required({
+                comment: "The working creature’s use.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});

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

@@ -0,0 +1,76 @@
+/**
+ * Herbary-related types.
+ */
+import * as DB from "tsondb/schema/dsl";
+export declare const EffectType: DB.Enum<"EffectType", {
+    Healing: DB.EnumCase<null>;
+    Poison: DB.EnumCase<null>;
+    PhysicalEffect: DB.EnumCase<null>;
+    PsychicEffect: DB.EnumCase<null>;
+    Beneficial: DB.EnumCase<null>;
+    Defensive: DB.EnumCase<null>;
+    Supernatural: DB.EnumCase<null>;
+}, []>;
+export declare const LaboratoryLevel: DB.Enum<"LaboratoryLevel", {
+    ArchaicLaboratory: DB.EnumCase<null>;
+    WitchKitchen: DB.EnumCase<null>;
+    AlchemistsLaboratory: DB.EnumCase<null>;
+}, []>;
+export declare const RecipeComplexity: DB.Enum<"RecipeComplexity", {
+    Primitive: DB.EnumCase<null>;
+    Simple: DB.EnumCase<null>;
+    Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"RecipeTradeSecret", 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>;
+    }>, []>>>;
+}, []>;
+export declare const RecipeTradeSecret: DB.TypeAlias<"RecipeTradeSecret", 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>;
+}>, []>;

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

@@ -0,0 +1,48 @@
+/**
+ * Herbary-related types.
+ */
+import * as DB from "tsondb/schema/dsl";
+import { PlainGeneralPrerequisites } from "../../_Prerequisite.js";
+export const EffectType = DB.Enum(import.meta.url, {
+    name: "EffectType",
+    comment: "Effect type categories of a plant or recipe.",
+    values: () => ({
+        Healing: DB.EnumCase({ type: null }),
+        Poison: DB.EnumCase({ type: null }),
+        PhysicalEffect: DB.EnumCase({ type: null }),
+        PsychicEffect: DB.EnumCase({ type: null }),
+        Beneficial: DB.EnumCase({ type: null }),
+        Defensive: DB.EnumCase({ type: null }),
+        Supernatural: DB.EnumCase({ type: null }),
+    }),
+});
+export const LaboratoryLevel = DB.Enum(import.meta.url, {
+    name: "LaboratoryLevel",
+    values: () => ({
+        ArchaicLaboratory: DB.EnumCase({ type: null }),
+        WitchKitchen: DB.EnumCase({ type: null }),
+        AlchemistsLaboratory: DB.EnumCase({ type: null }),
+    }),
+});
+export const RecipeComplexity = DB.Enum(import.meta.url, {
+    name: "RecipeComplexity",
+    comment: "The complexity of crafting the recipe.",
+    values: () => ({
+        Primitive: DB.EnumCase({ type: null }),
+        Simple: DB.EnumCase({ type: null }),
+        Complex: DB.EnumCase({ type: DB.IncludeIdentifier(RecipeTradeSecret) }),
+    }),
+});
+export const RecipeTradeSecret = DB.TypeAlias(import.meta.url, {
+    name: "RecipeTradeSecret",
+    type: () => DB.Object({
+        ap_value: DB.Required({
+            comment: "The AP value of the trade secret.",
+            type: DB.Integer({ minimum: 0 }),
+        }),
+        prerequisites: DB.Optional({
+            comment: "The prerequisites of the trade secret, if any.",
+            type: DB.IncludeIdentifier(PlainGeneralPrerequisites),
+        }),
+    }),
+});