@optolith/database-schema 0.42.1

package/lib/types/DerivedCharacteristic.d.ts

@@ -0,0 +1,267 @@
+import * as DB from "tsondb/schema/dsl";
+import type { DerivedCharacteristicBase } from "../../gen/types.js";
+import { MathOperation } from "./_MathExpression.ts";
+export declare const DerivedCharacteristic: DB.Entity<"DerivedCharacteristic", {
+    position: DB.MemberDecl<DB.Integer, true>;
+    type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DerivedCharacteristicType", {
+        Energy: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"EnergyType", DB.Object<{
+            purchase: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicPurchase", DB.Object<{
+                improvementCost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ImprovementCost", {
+                    A: DB.EnumCase<null>;
+                    B: DB.EnumCase<null>;
+                    C: DB.EnumCase<null>;
+                    D: DB.EnumCase<null>;
+                }, []>>, true>;
+                maximum: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicBase", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], MathOperation>, []>>, true>;
+            }>, []>>, false>;
+            permanentLoss: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicPermanentLoss", DB.Object<{
+                canBeBoughtBack: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicBuyBack", DB.Object<{
+                    cost: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>, false>;
+            }>, []>>, false>;
+        }>, []>>>;
+        Resistance: DB.EnumCase<null>;
+    }, []>>, false>;
+    calculation: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicCalculation", DB.Object<{
+        base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicBase", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], MathOperation>, []>>, true>;
+        modifiers: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicModifier", DB.Object<{
+            source: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DerivedCharacteristicModifierPrerequisiteGroup", {
+                Rule: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"RulePrerequisite", DB.Object<{
+                    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ExtensionRuleIdentifier", {
+                        FocusRule: DB.EnumCase<DB.ReferenceIdentifier>;
+                        OptionalRule: DB.EnumCase<DB.ReferenceIdentifier>;
+                    }, []>>, 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>;
+                }>, []>>>;
+                Activatable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ActivatablePrerequisite", DB.Object<{
+                    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
+                        AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                        AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                        AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                        AdvancedSkillSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                        AncestorGlyph: DB.EnumCase<DB.ReferenceIdentifier>;
+                        ArcaneOrbEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                        AttireEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Beutelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+                        BlessedTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+                        BowlEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                        BrawlingSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                        CauldronEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                        CeremonialItemSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                        ChronicleEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                        CombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                        CombatStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                        CommandSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                        DaggerRitual: DB.EnumCase<DB.ReferenceIdentifier>;
+                        FamiliarSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                        FatePointSexSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                        FatePointSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                        FoolsHatEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                        GeneralSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Haubenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+                        InstrumentEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                        KarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Krallenkettenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Kristallkugelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+                        LiturgicalStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                        LycantropicGift: DB.EnumCase<DB.ReferenceIdentifier>;
+                        MagicalSign: DB.EnumCase<DB.ReferenceIdentifier>;
+                        MagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                        MagicalTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+                        MagicStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                        OrbEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                        PactGift: DB.EnumCase<DB.ReferenceIdentifier>;
+                        ProtectiveWardingCircleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                        RingEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Sermon: DB.EnumCase<DB.ReferenceIdentifier>;
+                        SexSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                        SickleRitual: DB.EnumCase<DB.ReferenceIdentifier>;
+                        SikaryanDrainSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                        SkillStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                        SpellSwordEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                        StaffEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                        ToyEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Trinkhornzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+                        VampiricGift: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Vision: DB.EnumCase<DB.ReferenceIdentifier>;
+                        WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                        WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                    }, []>>, true>;
+                    active: DB.MemberDecl<DB.Boolean, true>;
+                    level: DB.MemberDecl<DB.Integer, false>;
+                    options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+                        General: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Race: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Skill: DB.EnumCase<DB.ReferenceIdentifier>;
+                        SkillApplication: DB.EnumCase<DB.ReferenceIdentifier>;
+                        CloseCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+                        RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Property: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Aspect: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Language: DB.EnumCase<DB.ReferenceIdentifier>;
+                        AnimalShape: DB.EnumCase<DB.ReferenceIdentifier>;
+                        LiturgicalChant: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Ceremony: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Spell: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
+                        TradeSecret: DB.EnumCase<DB.ReferenceIdentifier>;
+                        ArcaneBardTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+                        ArcaneDancerTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Element: DB.EnumCase<DB.ReferenceIdentifier>;
+                    }, []>>>, false>;
+                    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>;
+                    when: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Preconditions", DB.Array<DB.IncludeIdentifier<[], DB.Enum<"PreconditionGroup", {
+                        Publication: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationPrerequisite", DB.Object<{
+                            id: DB.MemberDecl<DB.ReferenceIdentifier, 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>;
+                        }>, []>>>;
+                        Rule: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"RulePrerequisite", DB.Object<{
+                            id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ExtensionRuleIdentifier", {
+                                FocusRule: DB.EnumCase<DB.ReferenceIdentifier>;
+                                OptionalRule: DB.EnumCase<DB.ReferenceIdentifier>;
+                            }, []>>, 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>;
+                        }>, []>>>;
+                        SexualCharacteristic: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SexualCharacteristicPrerequisite", DB.Object<{
+                            id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SexualCharacteristic", {
+                                Penis: DB.EnumCase<null>;
+                                Vagina: DB.EnumCase<null>;
+                            }, []>>, true>;
+                        }>, []>>>;
+                    }, []>>>, []>>, false>;
+                }>, []>>>;
+            }, []>>, true>;
+            operation: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DerivedCharacteristicModifierOperation", {
+                Addition: DB.EnumCase<null>;
+                Subtraction: DB.EnumCase<null>;
+                Multiplication: DB.EnumCase<null>;
+                Division: DB.EnumCase<null>;
+            }, []>>, true>;
+            value: DB.MemberDecl<DB.Integer, true>;
+        }>, []>>>, false>;
+    }>, []>>, true>;
+    prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+        Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+        Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                Hide: DB.EnumCase<null>;
+                ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                    sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                        Standalone: DB.EnumCase<null>;
+                        Connected: DB.EnumCase<null>;
+                    }, []>>, false>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                        replacement: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, false>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+        Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                text: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+    }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
+    src: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRefs", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRef", DB.Object<{
+        id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {
+            initial: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"InitialOccurrence", DB.Object<{
+                printing: DB.MemberDecl<DB.Integer, false>;
+                pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                    first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                        InsideCoverFront: DB.EnumCase<null>;
+                        InsideCoverBack: DB.EnumCase<null>;
+                        Numbered: DB.EnumCase<DB.Integer>;
+                    }, []>>, true>;
+                    last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                        InsideCoverFront: DB.EnumCase<null>;
+                        InsideCoverBack: DB.EnumCase<null>;
+                        Numbered: DB.EnumCase<DB.Integer>;
+                    }, []>>, false>;
+                }>, []>>>, true>;
+                isRemoved: DB.MemberDecl<DB.Boolean, false>;
+            }>, []>>, true>;
+            revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
+                Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
+                    printing: DB.MemberDecl<DB.Integer, true>;
+                    pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                        first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                            InsideCoverFront: DB.EnumCase<null>;
+                            InsideCoverBack: DB.EnumCase<null>;
+                            Numbered: DB.EnumCase<DB.Integer>;
+                        }, []>>, true>;
+                        last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                            InsideCoverFront: DB.EnumCase<null>;
+                            InsideCoverBack: DB.EnumCase<null>;
+                            Numbered: DB.EnumCase<DB.Integer>;
+                        }, []>>, false>;
+                    }>, []>>>, true>;
+                }>, []>>>;
+                Deprecated: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Deprecation", DB.Object<{
+                    printing: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>>, false>;
+        }>, true>;
+    }>, []>>>, []>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"DerivedCharacteristicTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        abbreviation: DB.MemberDecl<DB.String, true>;
+        description: DB.MemberDecl<DB.String, false>;
+        calculation: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CalculationTranslation", DB.Object<{
+            default: DB.MemberDecl<DB.String, true>;
+            half_primary: DB.MemberDecl<DB.String, false>;
+            no_primary: DB.MemberDecl<DB.String, false>;
+        }>, []>>, false>;
+    }>, true>;
+}, undefined>;
+declare const DerivedCharacteristicBase: DB.TypeAlias<"DerivedCharacteristicBase", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], MathOperation>, []>;
+export declare const calculationContainsRaceBase: (base: DerivedCharacteristicBase) => boolean;
+export {};

package/lib/types/DerivedCharacteristic.js

@@ -0,0 +1,227 @@
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
+import * as DB from "tsondb/schema/dsl";
+import { fromUniformCase } from "tsondb/schema/gen";
+import { NestedTranslationMap } from "./Locale.js";
+import { AttributeIdentifier } from "./_Identifier.js";
+import { ImprovementCost } from "./_ImprovementCost.js";
+import { MathOperation } from "./_MathExpression.js";
+import { DerivedCharacteristicPrerequisites } from "./_Prerequisite.js";
+import { DerivedCharacteristicModifierPrerequisiteGroup } from "./prerequisites/PrerequisiteGroups.js";
+import { src } from "./source/_PublicationRef.js";
+export const DerivedCharacteristic = DB.Entity(import.meta.url, {
+    name: "DerivedCharacteristic",
+    namePlural: "DerivedCharacteristics",
+    type: () => DB.Object({
+        position: DB.Required({
+            comment: "The position of the derived characteristic in lists. This has to be a unique value.",
+            type: DB.Integer({ minimum: 0 }),
+        }),
+        type: DB.Optional({
+            comment: "The derived characteristic may have a specific use in the game.",
+            type: DB.IncludeIdentifier(DerivedCharacteristicType),
+        }),
+        calculation: DB.Required({
+            comment: "Instructions for calculating the derived characteristic’s value.",
+            type: DB.IncludeIdentifier(DerivedCharacteristicCalculation),
+        }),
+        prerequisites: DB.Optional({
+            type: DB.IncludeIdentifier(DerivedCharacteristicPrerequisites),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "DerivedCharacteristic", DB.Object({
+            name: DB.Required({
+                comment: "The derived characteristic’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            abbreviation: DB.Required({
+                comment: "The derived characteristic’s abbreviation.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            description: DB.Optional({
+                comment: "The derived characteristic’s description.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            calculation: DB.Optional({
+                comment: "Possible calculation strings for the final value.",
+                type: DB.IncludeIdentifier(CalculationTranslation),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    sortOrder: {
+        keyPath: "position",
+    },
+    uniqueConstraints: [
+        {
+            keyPath: "position",
+        },
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "abbreviation",
+        },
+    ],
+});
+const DerivedCharacteristicType = DB.Enum(import.meta.url, {
+    name: "DerivedCharacteristicType",
+    comment: "The type of the derived characteristic, which determines how it can be used in the game.",
+    values: () => ({
+        Energy: DB.EnumCase({
+            comment: "The derived characteristic works like an energy in that it can be spent on various actions and abilities, and also be refilled based on certain conditions.",
+            type: DB.IncludeIdentifier(EnergyType),
+        }),
+        Resistance: DB.EnumCase({
+            comment: "The derived characteristic represents a resistance against certain effects.",
+            type: null,
+        }),
+    }),
+});
+const EnergyType = DB.TypeAlias(import.meta.url, {
+    name: "EnergyType",
+    comment: "Additional values that can be defined for an energy.",
+    type: () => DB.Object({
+        purchase: DB.Optional({
+            comment: "If set, the energy’s maximum value can be improved by spending AP.\n\nIf the energy’s permanent losses can be bought back, points will not be able to be purchased unless all permanent losses have been bought back.",
+            type: DB.IncludeIdentifier(DerivedCharacteristicPurchase),
+        }),
+        permanentLoss: DB.Optional({
+            comment: "If set, the energy can suffer permanent losses that reduce its maximum value. It may also be possible to buy back these permanent losses.",
+            type: DB.IncludeIdentifier(DerivedCharacteristicPermanentLoss),
+        }),
+    }),
+});
+const DerivedCharacteristicCalculation = DB.TypeAlias(import.meta.url, {
+    name: "DerivedCharacteristicCalculation",
+    type: () => DB.Object({
+        base: DB.Required({
+            comment: "The base value for the calculation.",
+            type: DB.IncludeIdentifier(DerivedCharacteristicBase),
+        }),
+        modifiers: DB.Optional({
+            comment: "A list of modifiers that are applied to the base value. The modifiers are applied in the order they appear in the list.",
+            type: DB.Array(DB.IncludeIdentifier(DerivedCharacteristicModifier), { minItems: 1 }),
+        }),
+    }),
+});
+const DerivedCharacteristicPrimaryAttributeValue = DB.Enum(import.meta.url, {
+    name: "DerivedCharacteristicPrimaryAttributeValue",
+    values: () => ({
+        Magical: DB.EnumCase({ type: null }),
+        Blessed: DB.EnumCase({ type: null }),
+    }),
+});
+const DerivedCharacteristicBaseValue = DB.Enum(import.meta.url, {
+    name: "DerivedCharacteristicBaseValue",
+    values: () => ({
+        Constant: DB.EnumCase({ type: DB.Integer() }),
+        Attribute: DB.EnumCase({ type: AttributeIdentifier() }),
+        RaceBaseValue: DB.EnumCase({ displayName: "Base Value from Race", type: null }),
+        PrimaryAttribute: DB.EnumCase({
+            type: DB.IncludeIdentifier(DerivedCharacteristicPrimaryAttributeValue),
+        }),
+    }),
+});
+const DerivedCharacteristicBase = DB.TypeAlias(import.meta.url, {
+    name: "DerivedCharacteristicBase",
+    type: () => DB.GenIncludeIdentifier(MathOperation, [DB.IncludeIdentifier(DerivedCharacteristicBaseValue)]),
+});
+export const calculationContainsRaceBase = (base) => {
+    switch (base.kind) {
+        case "Value":
+            switch (base.Value.kind) {
+                case "RaceBaseValue":
+                    return true;
+                case "Constant":
+                case "Attribute":
+                case "PrimaryAttribute":
+                    return false;
+                default:
+                    return assertExhaustive(base.Value);
+            }
+        case "Addition":
+        case "Subtraction":
+        case "Multiplication":
+        case "Division":
+        case "Exponentiation": {
+            const [left, right] = fromUniformCase(base);
+            return calculationContainsRaceBase(left) || calculationContainsRaceBase(right);
+        }
+    }
+};
+const DerivedCharacteristicModifierOperation = DB.Enum(import.meta.url, {
+    name: "DerivedCharacteristicModifierOperation",
+    values: () => ({
+        Addition: DB.EnumCase({ type: null }),
+        Subtraction: DB.EnumCase({ type: null }),
+        Multiplication: DB.EnumCase({ type: null }),
+        Division: DB.EnumCase({ type: null }),
+    }),
+});
+const DerivedCharacteristicModifier = DB.TypeAlias(import.meta.url, {
+    name: "DerivedCharacteristicModifier",
+    type: () => DB.Object({
+        source: DB.Required({
+            comment: "The entry that, when active, causes the modifier.",
+            type: DB.IncludeIdentifier(DerivedCharacteristicModifierPrerequisiteGroup),
+        }),
+        operation: DB.Required({
+            comment: "The mathematical operation that modifies the base value. The previous result is on the left side.",
+            type: DB.IncludeIdentifier(DerivedCharacteristicModifierOperation),
+        }),
+        value: DB.Required({
+            comment: "The value that is used in the modifier operation. If the source entry has levels, the value is multiplied by the source entry’s level.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+    }),
+});
+const DerivedCharacteristicPurchase = DB.TypeAlias(import.meta.url, {
+    name: "DerivedCharacteristicPurchase",
+    type: () => DB.Object({
+        improvementCost: DB.Required({
+            comment: "The cost for improving the derived characteristic by one.",
+            type: DB.IncludeIdentifier(ImprovementCost),
+        }),
+        maximum: DB.Required({
+            comment: "The maximum value that can be achieved for the derived characteristic through improvements.",
+            type: DB.IncludeIdentifier(DerivedCharacteristicBase),
+        }),
+    }),
+});
+const DerivedCharacteristicPermanentLoss = DB.TypeAlias(import.meta.url, {
+    name: "DerivedCharacteristicPermanentLoss",
+    type: () => DB.Object({
+        canBeBoughtBack: DB.Optional({
+            comment: "If set, permanent losses to the derived characteristic can be bought back for the specified cost.",
+            type: DB.IncludeIdentifier(DerivedCharacteristicBuyBack),
+        }),
+    }),
+});
+const DerivedCharacteristicBuyBack = DB.TypeAlias(import.meta.url, {
+    name: "DerivedCharacteristicBuyBack",
+    type: () => DB.Object({
+        cost: DB.Required({
+            comment: "The AP cost for buying back one point.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+    }),
+});
+const CalculationTranslation = DB.TypeAlias(import.meta.url, {
+    name: "CalculationTranslation",
+    type: () => DB.Object({
+        default: DB.Required({
+            comment: "The default calculation string.",
+            type: DB.String({ minLength: 1 }),
+        }),
+        half_primary: DB.Optional({
+            comment: "The calculation string if only half of the primary attribute is used.",
+            type: DB.String({ minLength: 1 }),
+        }),
+        no_primary: DB.Optional({
+            comment: "The calculation string if no primary attribute is used.",
+            type: DB.String({ minLength: 1 }),
+        }),
+    }),
+});