@optolith/database-schema 0.42.1

package/lib/types/Spell.js

@@ -0,0 +1,96 @@
+import * as DB from "tsondb/schema/dsl";
+import { FastPerformanceParameters, OldParameter } from "./_ActivatableSkill.js";
+import { ActivatableSkillEffect } from "./_ActivatableSkillEffect.js";
+import { AffectedTargetCategories } from "./_ActivatableSkillTargetCategory.js";
+import { Enhancement } from "./_Enhancements.js";
+import { PropertyIdentifier } from "./_Identifier.js";
+import { ImprovementCost } from "./_ImprovementCost.js";
+import { SpellworkPrerequisites } from "./_Prerequisite.js";
+import { SkillCheck, SkillCheckPenalty } from "./_SkillCheck.js";
+import { reversalis, SpellworkTraditions } from "./_Spellwork.js";
+import { NestedTranslationMap } from "./Locale.js";
+import { Errata } from "./source/_Erratum.js";
+import { src } from "./source/_PublicationRef.js";
+export const Spell = DB.Entity(import.meta.url, {
+    name: "Spell",
+    namePlural: "Spells",
+    type: () => DB.Object({
+        check: DB.Required({
+            comment: "Lists the linked three attributes used to make a skill check.",
+            type: DB.IncludeIdentifier(SkillCheck),
+        }),
+        check_penalty: DB.Optional({
+            comment: "In some cases, the target's Spirit or Toughness is applied as a penalty.",
+            type: DB.IncludeIdentifier(SkillCheckPenalty),
+        }),
+        parameters: DB.Required({
+            comment: "Measurable parameters of a spell.",
+            type: DB.IncludeIdentifier(FastPerformanceParameters),
+        }),
+        target: DB.Required({
+            comment: "The target category – the kind of creature or object – the skill affects.",
+            type: DB.IncludeIdentifier(AffectedTargetCategories),
+        }),
+        property: DB.Required({
+            comment: "The associated property.",
+            type: PropertyIdentifier(),
+        }),
+        traditions: DB.Required({
+            comment: "The tradition(s) the spell is available for. It may be *generally* available to all traditions or it may be only familiar in specific traditions.",
+            type: DB.IncludeIdentifier(SpellworkTraditions),
+        }),
+        improvement_cost: DB.Required({
+            comment: "States which column is used to improve the skill.",
+            type: DB.IncludeIdentifier(ImprovementCost),
+        }),
+        prerequisites: DB.Optional({
+            comment: "The prerequisites for the spell.",
+            type: DB.IncludeIdentifier(SpellworkPrerequisites),
+        }),
+        reversalis,
+        src,
+        translations: NestedTranslationMap(DB.Required, "Spell", DB.Object({
+            name: DB.Required({
+                comment: "The spell’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            effect: DB.Required({
+                comment: "The effect description may be either a plain text or a text that is divided by a list of effects for each quality level. It may also be a list for each two quality levels.",
+                type: DB.IncludeIdentifier(ActivatableSkillEffect),
+            }),
+            casting_time: DB.Optional({
+                isDeprecated: true,
+                type: DB.IncludeIdentifier(OldParameter),
+            }),
+            cost: DB.Optional({
+                isDeprecated: true,
+                type: DB.IncludeIdentifier(OldParameter),
+            }),
+            range: DB.Optional({
+                isDeprecated: true,
+                type: DB.IncludeIdentifier(OldParameter),
+            }),
+            duration: DB.Optional({
+                isDeprecated: true,
+                type: DB.IncludeIdentifier(OldParameter),
+            }),
+            target: DB.Optional({
+                isDeprecated: true,
+                type: DB.String({ minLength: 1 }),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+        enhancements: DB.Required({
+            type: DB.ChildEntities(Enhancement),
+        }),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});

package/lib/types/State.d.ts

@@ -0,0 +1,52 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const State: DB.Entity<"State", {
+    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<"StateTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        description: 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/State.js

@@ -0,0 +1,31 @@
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "./Locale.js";
+import { Errata } from "./source/_Erratum.js";
+import { src } from "./source/_PublicationRef.js";
+export const State = DB.Entity(import.meta.url, {
+    name: "State",
+    namePlural: "States",
+    type: () => DB.Object({
+        src,
+        translations: NestedTranslationMap(DB.Required, "State", DB.Object({
+            name: DB.Required({
+                comment: "The state’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            description: DB.Required({
+                comment: "The description of the state.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});

package/lib/types/Talisman.d.ts

@@ -0,0 +1,135 @@
+import * as DB from "tsondb/schema/dsl";
+import { MathOperation } from "./_MathExpression.js";
+export declare const Talisman: DB.Entity<"Talisman", {
+    tradition: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+    type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"TalismanType", {
+        MainTalisman: DB.EnumCase<null>;
+        Talisman: DB.EnumCase<null>;
+        MinorTalisman: DB.EnumCase<null>;
+        Regalia: DB.EnumCase<null>;
+        PowerfulTalisman: DB.EnumCase<null>;
+    }, []>>, false>;
+    activation: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"TalismanActivation", DB.Object<{
+        cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"TalismanActivationCost", DB.Object<{
+            value: DB.MemberDecl<DB.Integer, true>;
+            unit: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        }>, []>>, true>;
+        duration: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"TalismanActivationDuration", DB.Object<{
+            value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"TalismanActivationDurationExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], MathOperation>, []>>, true>;
+            unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationUnit", {
+                Seconds: DB.EnumCase<null>;
+                Minutes: DB.EnumCase<null>;
+                Hours: DB.EnumCase<null>;
+                Days: DB.EnumCase<null>;
+                Weeks: DB.EnumCase<null>;
+                Months: DB.EnumCase<null>;
+                Years: DB.EnumCase<null>;
+                Centuries: DB.EnumCase<null>;
+                Actions: DB.EnumCase<null>;
+                CombatRounds: DB.EnumCase<null>;
+            }, []>>, true>;
+        }>, []>>, true>;
+    }>, []>>, false>;
+    ap_value: DB.MemberDecl<DB.Integer, false>;
+    combatUse: DB.MemberDecl<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>;
+    }>, 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<"TalismanTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        effect: 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>;
+export declare const TalismanActivationDurationExpression: DB.TypeAlias<"TalismanActivationDurationExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], MathOperation>, []>;
+export declare const TalismanActivationDurationExpressionValue: DB.Enum<"TalismanActivationDurationExpressionValue", {
+    Constant: DB.EnumCase<DB.Integer>;
+    QualityLevels: DB.EnumCase<null>;
+}, []>;

package/lib/types/Talisman.js

@@ -0,0 +1,168 @@
+import * as DB from "tsondb/schema/dsl";
+import { DurationUnit } from "./_ActivatableSkillDuration.js";
+import { Dice } from "./_Dice.js";
+import { BlessedTraditionIdentifier, DerivedCharacteristicIdentifier } from "./_Identifier.js";
+import { MathOperation } from "./_MathExpression.js";
+import { CloseCombatTechnique, RangedCombatTechnique } from "./CombatTechnique.js";
+import { GenMeleeWeapon } from "./equipment/item/_MeleeWeapon.js";
+import { GenRangedWeapon } from "./equipment/item/_RangedWeapon.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./equipment/item/_Weapon.js";
+import { NestedTranslationMap } from "./Locale.js";
+import { Errata } from "./source/_Erratum.js";
+import { src } from "./source/_PublicationRef.js";
+export const Talisman = DB.Entity(import.meta.url, {
+    name: "Talisman",
+    namePlural: "Talismans",
+    type: () => DB.Object({
+        tradition: DB.Required({
+            comment: "The tradition(s) the talisman belongs to.",
+            type: DB.Array(BlessedTraditionIdentifier(), { minItems: 1 }),
+        }),
+        type: DB.Optional({
+            comment: "The talisman type, if any.",
+            type: DB.IncludeIdentifier(TalismanType),
+        }),
+        activation: DB.Optional({
+            comment: "The activation parameters.",
+            type: DB.IncludeIdentifier(TalismanActivation),
+        }),
+        ap_value: DB.Optional({
+            comment: "The AP value for the required trade secret, if possible.",
+            type: DB.Integer({ minimum: 5, multipleOf: 5 }),
+        }),
+        combatUse: DB.Optional({
+            type: DB.Object({
+                melee_uses: DB.Optional({
+                    comment: "A list of stat blocks for each close combat technique this talisman can be used with.",
+                    type: DB.NestedEntityMap({
+                        name: "MeleeTalismanUse",
+                        namePlural: "MeleeTalismanUses",
+                        secondaryEntity: CloseCombatTechnique,
+                        type: DB.IncludeIdentifier(TalismanMeleeWeapon),
+                        minProperties: 1,
+                    }),
+                }),
+                ranged_uses: DB.Optional({
+                    comment: "A list of stat blocks for each ranged combat technique this talisman can be used with.",
+                    type: DB.NestedEntityMap({
+                        name: "RangedTalismanUse",
+                        namePlural: "RangedTalismanUses",
+                        secondaryEntity: RangedCombatTechnique,
+                        type: DB.IncludeIdentifier(TalismanRangedWeapon),
+                        minProperties: 1,
+                    }),
+                }),
+            }, { minProperties: 1 }),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "Talisman", DB.Object({
+            name: DB.Required({
+                comment: "The talisman’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            effect: DB.Required({
+                comment: "The effect description.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+    customConstraints: ({ instanceContent, getInstanceById, getDisplayNameAndId }) => instanceContent.combatUse
+        ? checkWeaponCombatTechniqueIntegrity({
+            instanceContent: instanceContent.combatUse,
+            getDisplayNameAndId,
+            getInstanceById,
+        }, { secondary: true })
+        : [],
+});
+const TalismanMeleeWeapon = DB.TypeAlias(import.meta.url, {
+    name: "TalismanMeleeWeapon",
+    type: () => DB.GenIncludeIdentifier(GenMeleeWeapon, [DB.IncludeIdentifier(TalismanDamage)]),
+});
+const TalismanRangedWeapon = DB.TypeAlias(import.meta.url, {
+    name: "TalismanRangedWeapon",
+    type: () => DB.GenIncludeIdentifier(GenRangedWeapon, [DB.IncludeIdentifier(TalismanDamage)]),
+});
+const TalismanDamage = DB.TypeAlias(import.meta.url, {
+    name: "TalismanDamage",
+    type: () => DB.GenIncludeIdentifier(MathOperation, [DB.IncludeIdentifier(TalismanDamageOption)]),
+});
+const TalismanDamageOption = DB.Enum(import.meta.url, {
+    name: "TalismanDamageOption",
+    values: () => ({
+        Random: DB.EnumCase({ type: DB.IncludeIdentifier(Dice) }),
+        Constant: DB.EnumCase({ type: null }),
+        QualityLevels: DB.EnumCase({ type: null }),
+    }),
+});
+const TalismanType = DB.Enum(import.meta.url, {
+    name: "TalismanType",
+    values: () => ({
+        MainTalisman: DB.EnumCase({ type: null }),
+        Talisman: DB.EnumCase({ type: null }),
+        MinorTalisman: DB.EnumCase({ type: null }),
+        Regalia: DB.EnumCase({ type: null }),
+        PowerfulTalisman: DB.EnumCase({ type: null }),
+    }),
+});
+const TalismanActivation = DB.TypeAlias(import.meta.url, {
+    name: "TalismanActivation",
+    type: () => DB.Object({
+        cost: DB.Required({
+            comment: "The cost to activate the talisman.",
+            type: DB.IncludeIdentifier(TalismanActivationCost),
+        }),
+        duration: DB.Required({
+            comment: "The duration of how long the talisman will be active.",
+            type: DB.IncludeIdentifier(TalismanActivationDuration),
+        }),
+    }),
+});
+const TalismanActivationCost = DB.TypeAlias(import.meta.url, {
+    name: "TalismanActivationCost",
+    type: () => DB.Object({
+        value: DB.Required({
+            comment: "The (numeric) cost value.",
+            type: DB.Integer({ minimum: 0 }),
+        }),
+        unit: DB.Required({
+            comment: "The unit in which to pay the cost.",
+            type: DerivedCharacteristicIdentifier(),
+        }),
+    }),
+});
+const TalismanActivationDuration = DB.TypeAlias(import.meta.url, {
+    name: "TalismanActivationDuration",
+    type: () => DB.Object({
+        value: DB.Required({
+            comment: "The (numeric) duration value.",
+            type: DB.IncludeIdentifier(TalismanActivationDurationExpression),
+        }),
+        unit: DB.Required({
+            comment: "The unit of the duration.",
+            type: DB.IncludeIdentifier(DurationUnit),
+        }),
+    }),
+});
+export const TalismanActivationDurationExpression = DB.TypeAlias(import.meta.url, {
+    name: "TalismanActivationDurationExpression",
+    type: () => DB.GenIncludeIdentifier(MathOperation, [
+        DB.IncludeIdentifier(TalismanActivationDurationExpressionValue),
+    ]),
+});
+export const TalismanActivationDurationExpressionValue = DB.Enum(import.meta.url, {
+    name: "TalismanActivationDurationExpressionValue",
+    values: () => ({
+        Constant: DB.EnumCase({ type: DB.Integer({ minimum: 1 }) }),
+        QualityLevels: DB.EnumCase({ type: null }),
+    }),
+});

package/lib/types/TargetCategory.d.ts

@@ -0,0 +1,7 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const TargetCategory: DB.Entity<"TargetCategory", {
+    parent: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"TargetCategoryTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+    }>, true>;
+}, undefined>;

package/lib/types/TargetCategory.js

@@ -0,0 +1,26 @@
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "./Locale.js";
+import { TargetCategoryIdentifier } from "./_Identifier.js";
+export const TargetCategory = DB.Entity(import.meta.url, {
+    name: "TargetCategory",
+    namePlural: "TargetCategories",
+    type: () => DB.Object({
+        parent: DB.Optional({
+            comment: "A superordinate target category, if present.",
+            type: TargetCategoryIdentifier(),
+        }),
+        translations: NestedTranslationMap(DB.Required, "TargetCategory", DB.Object({
+            name: DB.Required({
+                comment: "The target category’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});

package/lib/types/_Activatable.d.ts

@@ -0,0 +1,12 @@
+/**
+ * General type specifications used by multiple activatable entries.
+ */
+import * as DB from "tsondb/schema/dsl";
+export declare const name: DB.MemberDecl<DB.String, true>;
+export declare const name_in_library: DB.MemberDecl<DB.String, false>;
+export declare const levels: DB.MemberDecl<DB.Integer, false>;
+export declare const maximum: DB.MemberDecl<DB.Integer, false>;
+export declare const rules: DB.MemberDecl<DB.String, true>;
+export declare const effect: DB.MemberDecl<DB.String, true>;
+export declare const range_l10n: DB.MemberDecl<DB.String, false>;
+export declare const input: DB.MemberDecl<DB.String, false>;

package/lib/types/_Activatable.js

@@ -0,0 +1,43 @@
+/**
+ * General type specifications used by multiple activatable entries.
+ */
+import * as DB from "tsondb/schema/dsl";
+export const name = DB.Required({
+    comment: "Name of the activatable entry.",
+    type: DB.String({ minLength: 1 }),
+});
+export const name_in_library = DB.Optional({
+    comment: "The full name of the entry as stated in the sources. Only use when `name` needs to be different from full name for text generation purposes.",
+    type: DB.String({ minLength: 1 }),
+});
+export const levels = DB.Optional({
+    comment: "Number of available levels.",
+    type: DB.Integer({ minimum: 2 }),
+});
+export const maximum = DB.Optional({
+    comment: `The number stating how often you can buy the entry. The **default** depends on the entry type:
+
+- **Advantage:** \`1\` in all cases (as specified in the **Core Rules**)
+- **Disadvantage:** \`1\` in all cases (as specified in the **Core Rules**)
+- **Special Abilities:** \`1\` if no options can be selected, otherwise the number of possible options
+
+The maximum is only set if it differs from the defaults specified above.`,
+    type: DB.Integer({ minimum: 1 }),
+});
+export const rules = DB.Required({
+    comment: "The rule text.",
+    type: DB.String({ minLength: 1, markdown: "block" }),
+});
+export const effect = DB.Required({
+    comment: "The effect description.",
+    type: DB.String({ minLength: 1, markdown: "block" }),
+});
+export const range_l10n = DB.Optional({
+    comment: "The range of the advantage.",
+    isDeprecated: true,
+    type: DB.String({ minLength: 1 }),
+});
+export const input = DB.Optional({
+    comment: "A string that is used as a label for an input field.",
+    type: DB.String({ minLength: 1 }),
+});

package/lib/types/_ActivatableAdvanced.d.ts

@@ -0,0 +1,50 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const advanced: (identifier: DB.Type) => DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"AdvancedSpecialAbility", {
+    General: DB.EnumCase<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>>;
+    RestrictOptions: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"RestrictAdvancedSpecialAbilityOptions", DB.Object<{
+        id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
+        option: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"AdvancedSpecialAbilityRestrictedOptionIdentifier", {
+            General: DB.EnumCase<DB.ReferenceIdentifier>;
+            Skill: DB.EnumCase<DB.ReferenceIdentifier>;
+            CloseCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+            RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+            Element: DB.EnumCase<DB.ReferenceIdentifier>;
+            Aspect: DB.EnumCase<DB.ReferenceIdentifier>;
+        }, []>>>, true>;
+    }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>;
+    OneOf: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"OneOfAdvancedSpecialAbilityOptions", DB.Object<{
+        options: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>>, true>;
+        is_selection_required_on_purchase: DB.MemberDecl<DB.Boolean, true>;
+        display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+            Hide: DB.EnumCase<null>;
+            ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                    Standalone: DB.EnumCase<null>;
+                    Connected: DB.EnumCase<null>;
+                }, []>>, false>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                    replacement: DB.MemberDecl<DB.String, true>;
+                }>, true>;
+            }>, []>>>;
+        }, []>>, false>;
+    }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>;
+    DeriveFromExternalOption: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"AdvancedSpecialAbilityDerivedFromExternalOption", DB.Object<{
+        external_entry: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        map: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"AdvancedSpecialAbilityDerivedFromExternalOptionMapping", DB.Object<{
+            from_option: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            to_advanced: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
+        }>, [Identifier: DB.Param<"Identifier", 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>;
+    }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>;
+}, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, true>;