optolith-database-schema 0.21.2 → 0.22.0

package/lib/types/_ActivatableAdvanced.d.ts

@@ -0,0 +1,50 @@
+import { Array, Boolean, EnumCase, IncludeIdentifier, Object, type Type, TypeArgument } from "tsondb/schema/def";
+export declare const advanced: (identifier: Type) => import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], import("tsondb/schema/def").EnumDecl<"AdvancedSpecialAbility", {
+    General: EnumCase<TypeArgument<import("tsondb/schema/def").TypeParameter<"Identifier", Type>>>;
+    RestrictOptions: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], import("tsondb/schema/def").TypeAliasDecl<"RestrictAdvancedSpecialAbilityOptions", Object<{
+        id: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"Identifier", Type>>, true>;
+        option: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdvancedSpecialAbilityRestrictedOptionIdentifier", {
+            General: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            Skill: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            CloseCombatTechnique: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            RangedCombatTechnique: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            Element: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            Aspect: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        }, []>>>, true>;
+    }>, [Identifier: import("tsondb/schema/def").TypeParameter<"Identifier", Type>]>>>;
+    OneOf: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], import("tsondb/schema/def").TypeAliasDecl<"OneOfAdvancedSpecialAbilityOptions", Object<{
+        options: import("tsondb/schema/def").MemberDecl<Array<TypeArgument<import("tsondb/schema/def").TypeParameter<"Identifier", Type>>>, true>;
+        is_selection_required_on_purchase: import("tsondb/schema/def").MemberDecl<Boolean, true>;
+        display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"DisplayOption", {
+            Hide: EnumCase<null>;
+            ReplaceWith: EnumCase<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"ReplacementDisplayOption", Object<{
+                sentence_type: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"SentenceType", {
+                    Standalone: EnumCase<null>;
+                    Connected: EnumCase<null>;
+                }, []>>, false>;
+                translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"ReplacementDisplayOptionTranslation", {
+                    replacement: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
+                }>, true>;
+            }>, []>>>;
+        }, []>>, false>;
+    }>, [Identifier: import("tsondb/schema/def").TypeParameter<"Identifier", Type>]>>>;
+    DeriveFromExternalOption: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], import("tsondb/schema/def").TypeAliasDecl<"AdvancedSpecialAbilityDerivedFromExternalOption", Object<{
+        external_entry: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+        map: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], import("tsondb/schema/def").TypeAliasDecl<"AdvancedSpecialAbilityDerivedFromExternalOptionMapping", Object<{
+            from_option: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+            to_advanced: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"Identifier", Type>>, true>;
+        }>, [Identifier: import("tsondb/schema/def").TypeParameter<"Identifier", Type>]>>>, true>;
+        display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"DisplayOption", {
+            Hide: EnumCase<null>;
+            ReplaceWith: EnumCase<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"ReplacementDisplayOption", Object<{
+                sentence_type: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"SentenceType", {
+                    Standalone: EnumCase<null>;
+                    Connected: EnumCase<null>;
+                }, []>>, false>;
+                translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"ReplacementDisplayOptionTranslation", {
+                    replacement: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
+                }>, true>;
+            }>, []>>>;
+        }, []>>, false>;
+    }>, [Identifier: import("tsondb/schema/def").TypeParameter<"Identifier", Type>]>>>;
+}, [Identifier: import("tsondb/schema/def").TypeParameter<"Identifier", Type>]>>>, true>;

package/lib/types/_ActivatableAdvanced.js

@@ -0,0 +1,97 @@
+import { Array, Boolean, EnumCase, GenEnum, GenIncludeIdentifier, GenTypeAlias, IncludeIdentifier, Object, Optional, Param, Required, TypeArgument, } from "tsondb/schema/def";
+import { MagicalTraditionIdentifier, PatronIdentifier } from "./_Identifier.js";
+import { AdvancedSpecialAbilityRestrictedOptionIdentifier } from "./_IdentifierGroup.js";
+import { DisplayOption } from "./prerequisites/DisplayOption.js";
+const AdvancedSpecialAbility = GenEnum(import.meta.url, {
+    name: "AdvancedSpecialAbility",
+    comment: "A reference to an advanced special ability.",
+    parameters: [Param("Identifier")],
+    values: Identifier => ({
+        General: EnumCase({ type: TypeArgument(Identifier) }),
+        RestrictOptions: EnumCase({
+            type: GenIncludeIdentifier(RestrictAdvancedSpecialAbilityOptions, [TypeArgument(Identifier)]),
+        }),
+        OneOf: EnumCase({
+            type: GenIncludeIdentifier(OneOfAdvancedSpecialAbilityOptions, [TypeArgument(Identifier)]),
+        }),
+        DeriveFromExternalOption: EnumCase({
+            type: GenIncludeIdentifier(AdvancedSpecialAbilityDerivedFromExternalOption, [
+                TypeArgument(Identifier),
+            ]),
+        }),
+    }),
+});
+const RestrictAdvancedSpecialAbilityOptions = GenTypeAlias(import.meta.url, {
+    name: "RestrictAdvancedSpecialAbilityOptions",
+    parameters: [Param("Identifier")],
+    type: Identifier => Object({
+        id: Required({
+            comment: "The advanced special ability’s identifier.",
+            type: TypeArgument(Identifier),
+        }),
+        option: Required({
+            comment: "Specify the select option(s) that only are allowed for the referenced advanced special ability; others are disallowed.",
+            type: Array(IncludeIdentifier(AdvancedSpecialAbilityRestrictedOptionIdentifier), {
+                minItems: 1,
+            }),
+        }),
+    }),
+});
+const OneOfAdvancedSpecialAbilityOptions = GenTypeAlias(import.meta.url, {
+    name: "OneOfAdvancedSpecialAbilityOptions",
+    parameters: [Param("Identifier")],
+    type: Identifier => Object({
+        options: Required({
+            comment: "The possible advanced special abilities.",
+            type: Array(TypeArgument(Identifier), { minItems: 2 }),
+        }),
+        is_selection_required_on_purchase: Required({
+            comment: "Do have to choose the advanced special ability when buying the style special ability? Otherwise the decision can be made later.",
+            type: Boolean(),
+        }),
+        display_option: Optional({
+            type: IncludeIdentifier(DisplayOption),
+        }),
+    }),
+});
+const AdvancedSpecialAbilityDerivedFromExternalOption = GenTypeAlias(import.meta.url, {
+    name: "AdvancedSpecialAbilityDerivedFromExternalOption",
+    parameters: [Param("Identifier")],
+    type: Identifier => Object({
+        external_entry: Required({
+            comment: "The possible advanced special abilities.",
+            type: MagicalTraditionIdentifier(),
+        }),
+        map: Required({
+            comment: "Map options from the external entry to allowed advanced special abilities.",
+            type: Array(GenIncludeIdentifier(AdvancedSpecialAbilityDerivedFromExternalOptionMapping, [
+                TypeArgument(Identifier),
+            ]), { minItems: 1 }),
+        }),
+        display_option: Optional({
+            type: IncludeIdentifier(DisplayOption),
+        }),
+    }),
+});
+const AdvancedSpecialAbilityDerivedFromExternalOptionMapping = GenTypeAlias(import.meta.url, {
+    name: "AdvancedSpecialAbilityDerivedFromExternalOptionMapping",
+    parameters: [Param("Identifier")],
+    comment: "Mapping from an option of the external entry to an allowed advanced special ability.",
+    type: Identifier => Object({
+        from_option: Required({
+            comment: "The select option’s identifier.",
+            type: PatronIdentifier(),
+        }),
+        to_advanced: Required({
+            comment: "The advanced special ability’s identifier.",
+            type: TypeArgument(Identifier),
+        }),
+    }),
+});
+export const advanced = (identifier) => Required({
+    comment: "The Advanced Special Abilities for the respective Style Special Ability. Sometimes, only a specific select option or a set of select options of an entry is allowed, which can be modelled by the option property. It can also be that you can choose from a set of special abilities, but then you can’t specify an option.",
+    type: Array(GenIncludeIdentifier(AdvancedSpecialAbility, [identifier]), {
+        minItems: 3,
+        maxItems: 3,
+    }),
+});

package/lib/types/_ActivatableAdventurePointsValue.d.ts

@@ -0,0 +1,152 @@
+import { ArrayType as Array, EnumDecl as Enum, EnumCaseDecl as EnumCase, IncludeIdentifier, IntegerType as Integer, ObjectType as Object, String, TypeAlias } from "tsondb/schema/def";
+import { MathOperation } from "./_MathExpression.js";
+export declare const ap_value: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"AdventurePointsValue", {
+    Fixed: EnumCase<IncludeIdentifier<[], TypeAlias<"FixedAdventurePointsValue", IncludeIdentifier<[], TypeAlias<"AdventurePointsSingleValue", Integer, []>>, []>>>;
+    ByLevel: EnumCase<IncludeIdentifier<[], TypeAlias<"AdventurePointsValueByLevel", Object<{
+        list: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"AdventurePointsSingleValue", Integer, []>>>, true>;
+        additionalBySizeCategory: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"BySizeCategory", Object<{
+            tiny: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").TypeArgumentType<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>, true>;
+            small: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").TypeArgumentType<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>, true>;
+            medium: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").TypeArgumentType<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>, true>;
+            large: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").TypeArgumentType<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>, true>;
+            huge: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").TypeArgumentType<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>, true>;
+        }>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, false>;
+    }>, []>>>;
+    DerivedFromSelection: EnumCase<IncludeIdentifier<[], TypeAlias<"AdventurePointsDerivedFromSelection", Object<{
+        translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"AdventurePointsDerivedFromSelectionTranslation", {
+            replacement: import("tsondb/schema/def").MemberDecl<String, false>;
+        }>, false>;
+    }>, []>>>;
+    DependingOnActive: EnumCase<IncludeIdentifier<[], TypeAlias<"AdventurePointsDependingOnActive", Object<{
+        id: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"ActivatableIdentifier", {
+            Advantage: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            Disadvantage: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            AdvancedCombatSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            AdvancedKarmaSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            AdvancedMagicalSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            AdvancedSkillSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            AncestorGlyph: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            ArcaneOrbEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            AttireEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            BlessedTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            BowlEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            BrawlingSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            CauldronEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            CeremonialItemSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            ChronicleEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            CombatSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            CombatStyleSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            CommandSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            DaggerRitual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            FamiliarSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            FatePointSexSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            FatePointSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            FoolsHatEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            GeneralSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            InstrumentEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            KarmaSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            Krallenkettenzauber: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            LiturgicalStyleSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            LycantropicGift: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            MagicalSign: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            MagicalSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            MagicalTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            MagicStyleSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            OrbEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            PactGift: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            ProtectiveWardingCircleSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            RingEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            Sermon: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            SexSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            SickleRitual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            SikaryanDrainSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            SkillStyleSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            SpellSwordEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            StaffEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            ToyEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            Trinkhornzauber: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            VampiricGift: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            Vision: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            WandEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            WeaponEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        }, []>>, true>;
+        active: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"AdventurePointsSingleValue", Integer, []>>, true>;
+        inactive: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"AdventurePointsSingleValue", Integer, []>>, true>;
+    }>, []>>>;
+    DependingOnActiveInstances: EnumCase<IncludeIdentifier<[], Enum<"AdventurePointsDependingOnActiveInstances", {
+        Threshold: EnumCase<IncludeIdentifier<[], TypeAlias<"AdventurePointsDependingOnActiveInstancesThreshold", Object<{
+            normal: import("tsondb/schema/def").MemberDecl<Integer, true>;
+            threshold: import("tsondb/schema/def").MemberDecl<Integer, true>;
+            alternative: import("tsondb/schema/def").MemberDecl<Integer, true>;
+        }>, []>>>;
+        Expression: EnumCase<IncludeIdentifier<[], TypeAlias<"AdventurePointsDependingOnActiveInstancesExpression", IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], MathOperation>, []>>>;
+    }, []>>>;
+    Indefinite: EnumCase<null>;
+}, []>>, true>;
+export declare const ap_value_l10n: import("tsondb/schema/def").MemberDecl<String, false>;
+export declare const ap_value_append: import("tsondb/schema/def").MemberDecl<String, false>;
+export declare const FixedAdventurePointsValue: TypeAlias<"FixedAdventurePointsValue", IncludeIdentifier<[], TypeAlias<"AdventurePointsSingleValue", Integer, []>>, []>;
+export declare const AdventurePointsDependingOnActive: TypeAlias<"AdventurePointsDependingOnActive", Object<{
+    id: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"ActivatableIdentifier", {
+        Advantage: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Disadvantage: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AdvancedCombatSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AdvancedKarmaSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AdvancedMagicalSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AdvancedSkillSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AncestorGlyph: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        ArcaneOrbEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AttireEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        BlessedTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        BowlEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        BrawlingSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        CauldronEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        CeremonialItemSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        ChronicleEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        CombatSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        CombatStyleSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        CommandSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        DaggerRitual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        FamiliarSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        FatePointSexSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        FatePointSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        FoolsHatEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        GeneralSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        InstrumentEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        KarmaSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Krallenkettenzauber: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        LiturgicalStyleSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        LycantropicGift: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        MagicalSign: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        MagicalSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        MagicalTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        MagicStyleSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        OrbEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        PactGift: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        ProtectiveWardingCircleSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        RingEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Sermon: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        SexSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        SickleRitual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        SikaryanDrainSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        SkillStyleSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        SpellSwordEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        StaffEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        ToyEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Trinkhornzauber: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        VampiricGift: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Vision: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        WandEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        WeaponEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+    }, []>>, true>;
+    active: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"AdventurePointsSingleValue", Integer, []>>, true>;
+    inactive: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"AdventurePointsSingleValue", Integer, []>>, true>;
+}>, []>;
+export declare const AdventurePointsDependingOnActiveInstances: Enum<"AdventurePointsDependingOnActiveInstances", {
+    Threshold: EnumCase<IncludeIdentifier<[], TypeAlias<"AdventurePointsDependingOnActiveInstancesThreshold", Object<{
+        normal: import("tsondb/schema/def").MemberDecl<Integer, true>;
+        threshold: import("tsondb/schema/def").MemberDecl<Integer, true>;
+        alternative: import("tsondb/schema/def").MemberDecl<Integer, true>;
+    }>, []>>>;
+    Expression: EnumCase<IncludeIdentifier<[], TypeAlias<"AdventurePointsDependingOnActiveInstancesExpression", IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], MathOperation>, []>>>;
+}, []>;

package/lib/types/_ActivatableAdventurePointsValue.js

@@ -0,0 +1,141 @@
+import { ArrayType as Array, EnumDecl as Enum, EnumCaseDecl as EnumCase, GenIncludeIdentifierType as GenIncludeIdentifier, IncludeIdentifier, IntegerType as Integer, ObjectType as Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
+import { ActivatableIdentifier } from "./_IdentifierGroup.js";
+import { MathOperation } from "./_MathExpression.js";
+import { BySizeCategory } from "./_SizeCategory.js";
+import { NestedTranslationMap } from "./Locale.js";
+const AdventurePointsValue = Enum(import.meta.url, {
+    name: "AdventurePointsValue",
+    values: () => ({
+        Fixed: EnumCase({ type: IncludeIdentifier(FixedAdventurePointsValue) }),
+        ByLevel: EnumCase({ type: IncludeIdentifier(AdventurePointsValueByLevel) }),
+        DerivedFromSelection: EnumCase({
+            type: IncludeIdentifier(AdventurePointsDerivedFromSelection),
+        }),
+        DependingOnActive: EnumCase({
+            type: IncludeIdentifier(AdventurePointsDependingOnActive),
+        }),
+        DependingOnActiveInstances: EnumCase({
+            type: IncludeIdentifier(AdventurePointsDependingOnActiveInstances),
+        }),
+        Indefinite: EnumCase({ type: null }),
+    }),
+});
+export const ap_value = Required({
+    comment: "The adventure points value.",
+    type: IncludeIdentifier(AdventurePointsValue),
+});
+export const ap_value_l10n = Optional({
+    comment: "The adventure points value.",
+    isDeprecated: true,
+    type: String({ minLength: 1 }),
+});
+export const ap_value_append = Optional({
+    comment: "The string to append to the generated AP value text.",
+    isDeprecated: true,
+    type: String({ minLength: 1 }),
+});
+export const FixedAdventurePointsValue = TypeAlias(import.meta.url, {
+    name: "FixedAdventurePointsValue",
+    comment: "A fixed adventure points value. If the entry has levels, this is the cost per level as well.",
+    type: () => IncludeIdentifier(AdventurePointsSingleValue),
+});
+const AdventurePointsValueByLevel = TypeAlias(import.meta.url, {
+    name: "AdventurePointsValueByLevel",
+    comment: "An entry with levels may have different costs for each level.",
+    type: () => Object({
+        list: Required({
+            comment: "The list of adventure point values, where the position in the list corresponds to the level (i.e. the first value is for level I, the second value is for level II, and so on). The length of the list must match the amount of levels the special ability has.",
+            type: Array(IncludeIdentifier(AdventurePointsSingleValue), { minItems: 2 }),
+        }),
+        additionalBySizeCategory: Optional({
+            comment: "Values may be added to each level based on the size category of the character. Negative values mean that the AP value is lowered.",
+            type: GenIncludeIdentifier(BySizeCategory, [Integer()]),
+        }),
+    }),
+});
+const AdventurePointsDerivedFromSelection = TypeAlias(import.meta.url, {
+    name: "AdventurePointsDerivedFromSelection",
+    comment: "The adventure points value is derived from the selection of the special ability. Its display value may be able to be derived from the given information for the select options. If that is not the case or the generated text would not match the original one, a replacement text can be provided.",
+    type: () => Object({
+        translations: NestedTranslationMap(Optional, "AdventurePointsDerivedFromSelection", Object({
+            replacement: Optional({
+                comment: "A replacement for the generated text if it would not match the original one.",
+                type: String({ minLength: 1, isMarkdown: true }),
+            }),
+        }, { minProperties: 1 })),
+    }),
+});
+const AdventurePointsSingleValue = TypeAlias(import.meta.url, {
+    name: "AdventurePointsSingleValue",
+    comment: "A single adventure points value.",
+    type: () => Integer({ minimum: 0 }),
+});
+export const AdventurePointsDependingOnActive = TypeAlias(import.meta.url, {
+    name: "AdventurePointsDependingOnActive",
+    comment: "The adventure points cost depends on if an instance of an entry is active.",
+    type: () => Object({
+        id: Required({
+            comment: "The identifier of the entry to that decides which AP value to pick.",
+            type: IncludeIdentifier(ActivatableIdentifier),
+        }),
+        active: Required({
+            comment: "The adventure points value if an instance of the referenced entry is active.",
+            type: IncludeIdentifier(AdventurePointsSingleValue),
+        }),
+        inactive: Required({
+            comment: "The adventure points value if no instance of the referenced entry is active.",
+            type: IncludeIdentifier(AdventurePointsSingleValue),
+        }),
+    }),
+});
+export const AdventurePointsDependingOnActiveInstances = Enum(import.meta.url, {
+    name: "AdventurePointsDependingOnActiveInstances",
+    comment: "The adventure points cost depends on how many instances of the entry are already active.",
+    values: () => ({
+        Threshold: EnumCase({
+            type: IncludeIdentifier(AdventurePointsDependingOnActiveInstancesThreshold),
+        }),
+        Expression: EnumCase({
+            type: IncludeIdentifier(AdventurePointsDependingOnActiveInstancesExpression),
+        }),
+    }),
+});
+const AdventurePointsDependingOnActiveInstancesThreshold = TypeAlias(import.meta.url, {
+    name: "AdventurePointsDependingOnActiveInstancesThreshold",
+    comment: "The adventure points cost depends on how many instances of the entry are already active.",
+    type: () => Object({
+        normal: Required({
+            comment: "The normal adventure points value.",
+            type: Integer({ minimum: 0 }),
+        }),
+        threshold: Required({
+            comment: "The number of active instances **after** which the alternative cost applies.",
+            type: Integer({ minimum: 1 }),
+        }),
+        alternative: Required({
+            comment: "The alternative adventure points value.",
+            type: Integer({ minimum: 0 }),
+        }),
+    }),
+});
+const AdventurePointsDependingOnActiveInstancesExpression = TypeAlias(import.meta.url, {
+    name: "AdventurePointsDependingOnActiveInstancesExpression",
+    comment: "The adventure points cost depends on how many instances of the entry are already active.",
+    type: () => GenIncludeIdentifier(MathOperation, [
+        IncludeIdentifier(AdventurePointsDependingOnActiveInstancesExpressionValue),
+    ]),
+});
+const AdventurePointsDependingOnActiveInstancesExpressionValue = Enum(import.meta.url, {
+    name: "AdventurePointsDependingOnActiveInstancesExpressionValue",
+    comment: `The type of value allowed in the expression to calculate the AP value.`,
+    values: () => ({
+        Constant: EnumCase({
+            comment: "A constant integer value.",
+            type: Integer(),
+        }),
+        Active: EnumCase({
+            comment: "The number of active instances.",
+            type: null,
+        }),
+    }),
+});

package/lib/types/_ActivatableAutomatic.d.ts

@@ -0,0 +1,71 @@
+import { Array, Boolean, Enum, EnumCase, IncludeIdentifier, Integer, Object, TypeAlias } from "tsondb/schema/def";
+export declare const automatic_entries: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"AutomaticEntry", Object<{
+    action: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"AutomaticEntryAction", {
+        Add: EnumCase<null>;
+        Remove: EnumCase<null>;
+    }, []>>, true>;
+    apply_ap_value: import("tsondb/schema/def").MemberDecl<Boolean, true>;
+    target: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"AutomaticEntryTarget", {
+        Selection: EnumCase<IncludeIdentifier<[], TypeAlias<"AutomaticEntryTargetSelection", Object<{
+            list: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"AutomaticEntryTargetSelectionList", {
+                MagicalTraditions: EnumCase<null>;
+                MagicalDilettanteTraditions: EnumCase<null>;
+            }, []>>, true>;
+        }>, []>>>;
+        Fixed: EnumCase<IncludeIdentifier<[], TypeAlias<"FixedAutomaticEntryTarget", Object<{
+            id: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"ActivatableIdentifier", {
+                Advantage: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                Disadvantage: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                AdvancedCombatSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                AdvancedKarmaSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                AdvancedMagicalSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                AdvancedSkillSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                AncestorGlyph: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                ArcaneOrbEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                AttireEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                BlessedTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                BowlEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                BrawlingSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                CauldronEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                CeremonialItemSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                ChronicleEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                CombatSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                CombatStyleSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                CommandSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                DaggerRitual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                FamiliarSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                FatePointSexSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                FatePointSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                FoolsHatEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                GeneralSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                InstrumentEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                KarmaSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                Krallenkettenzauber: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                LiturgicalStyleSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                LycantropicGift: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                MagicalSign: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                MagicalSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                MagicalTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                MagicStyleSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                OrbEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                PactGift: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                ProtectiveWardingCircleSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                RingEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                Sermon: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                SexSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                SickleRitual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                SikaryanDrainSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                SkillStyleSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                SpellSwordEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                StaffEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                ToyEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                Trinkhornzauber: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                VampiricGift: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                Vision: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                WandEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                WeaponEnchantment: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            }, []>>, true>;
+            level: import("tsondb/schema/def").MemberDecl<Integer, false>;
+        }>, []>>>;
+    }, []>>, true>;
+}>, []>>>, false>;

package/lib/types/_ActivatableAutomatic.js

@@ -0,0 +1,64 @@
+import { Array, Boolean, Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional, Required, TypeAlias, } from "tsondb/schema/def";
+import { ActivatableIdentifier } from "./_IdentifierGroup.js";
+const AutomaticEntry = TypeAlias(import.meta.url, {
+    name: "AutomaticEntry",
+    type: () => Object({
+        action: Required({
+            comment: "What type of action is applied to the target entry?",
+            type: IncludeIdentifier(AutomaticEntryAction),
+        }),
+        apply_ap_value: Required({
+            comment: "If an entry is added or removed, does is cost or grant adventure points or is it free of charge?",
+            type: Boolean(),
+        }),
+        target: Required({
+            comment: "The entry that is to be added or removed. It can be a fixed entry or a selection where the player must choose one entry.",
+            type: IncludeIdentifier(AutomaticEntryTarget),
+        }),
+    }),
+});
+export const automatic_entries = Optional({
+    comment: "This entry has a direct influence on the existence of other entries. It may add or remove entries.",
+    type: Array(IncludeIdentifier(AutomaticEntry), { minItems: 1 }),
+});
+const AutomaticEntryAction = Enum(import.meta.url, {
+    name: "AutomaticEntryAction",
+    values: () => ({
+        Add: EnumCase({ type: null }),
+        Remove: EnumCase({ type: null }),
+    }),
+});
+const AutomaticEntryTarget = Enum(import.meta.url, {
+    name: "AutomaticEntryTarget",
+    values: () => ({
+        Selection: EnumCase({ type: IncludeIdentifier(AutomaticEntryTargetSelection) }),
+        Fixed: EnumCase({ type: IncludeIdentifier(FixedAutomaticEntryTarget) }),
+    }),
+});
+const AutomaticEntryTargetSelection = TypeAlias(import.meta.url, {
+    name: "AutomaticEntryTargetSelection",
+    type: () => Object({
+        list: Required({
+            type: IncludeIdentifier(AutomaticEntryTargetSelectionList),
+        }),
+    }),
+});
+const AutomaticEntryTargetSelectionList = Enum(import.meta.url, {
+    name: "AutomaticEntryTargetSelectionList",
+    values: () => ({
+        MagicalTraditions: EnumCase({ type: null }),
+        MagicalDilettanteTraditions: EnumCase({ type: null }),
+    }),
+});
+const FixedAutomaticEntryTarget = TypeAlias(import.meta.url, {
+    name: "FixedAutomaticEntryTarget",
+    type: () => Object({
+        id: Required({
+            type: IncludeIdentifier(ActivatableIdentifier),
+        }),
+        level: Optional({
+            comment: "The level of the target entry to be added or removed. If this is omitted for a multi-level entry, level 1 is assumed.",
+            type: Integer({ minimum: 1 }),
+        }),
+    }),
+});