optolith-database-schema 0.20.6 → 0.21.1

package/lib/types/Disease.js

@@ -1,6 +1,7 @@
-import { Entity, Object, Required } from "tsondb/schema/def";
+import { Entity, IncludeIdentifier, Object, Optional, Required } from "tsondb/schema/def";
 import { NestedTranslationMap } from "./Locale.js";
 import { cause, DiseaseTranslation, level, resistance } from "./_DiseasePoison.js";
+import { RecipeTradeSecret } from "./equipment/item/_Herbary.js";
 import { src } from "./source/_PublicationRef.js";
 export const Disease = Entity(import.meta.url, {
     name: "Disease",
@@ -9,6 +10,10 @@ export const Disease = Entity(import.meta.url, {
         level,
         resistance,
         cause,
+        trade_secret: Optional({
+            comment: "AP value and prerequisites of the disease’s trade secret.",
+            type: IncludeIdentifier(RecipeTradeSecret),
+        }),
         src,
         translations: NestedTranslationMap(Required, "Disease", DiseaseTranslation),
     }),

package/lib/types/Patron.js

@@ -1,5 +1,5 @@
 import { Array, Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
-import { AdvantageIdentifier, AttributeIdentifier, CultureIdentifier, DisadvantageIdentifier, PatronCategoryIdentifier, SkillIdentifier, } from "./_Identifier.js";
+import { AdvantageIdentifier, AttributeIdentifier, DisadvantageIdentifier, PatronCategoryIdentifier, SkillIdentifier, TribeIdentifier, } from "./_Identifier.js";
 import { SpellworkIdentifier } from "./_IdentifierGroup.js";
 import { ImprovementCost } from "./_ImprovementCost.js";
 import { NestedTranslationMap } from "./Locale.js";
@@ -65,11 +65,9 @@ const PatronCulture = TypeAlias(import.meta.url, {
     comment: "The patron cultures the patron is or is not part of. If the patron is part of all patron cultures, the set should be empty and the operation should be difference.",
     type: () => Object({
         set: Required({
-            comment: "The AE cost value.",
-            type: Array(CultureIdentifier(), { uniqueItems: true }),
+            type: Array(TribeIdentifier(), { uniqueItems: true }),
         }),
         operation: Optional({
-            comment: "The interval in which you have to pay the AE cost again.",
             type: IncludeIdentifier(PatronCultureOperation),
         }),
     }),

package/lib/types/_Activatable.d.ts

@@ -664,168 +664,6 @@ export declare const select_options: import("tsondb/schema/def").MemberDecl<Incl
             }>, []>>>, true>;
         }>, []>>>;
     }, []>>, false>;
-    explicit: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], Enum<"ExplicitSelectOption", {
-        General: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
-        Skill: EnumCase<IncludeIdentifier<[], TypeAlias<"ExplicitSkillSelectOption", Object<{
-            id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-            prerequisites: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"GeneralPrerequisites", IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], TypeAlias<"PrerequisitesForLevels", Array<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], TypeAlias<"PrerequisiteForLevel", Object<{
-                level: import("tsondb/schema/def").MemberDecl<Integer, true>;
-                prerequisite: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], Enum<"PrerequisitesElement", {
-                    Single: EnumCase<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", Type>>>;
-                    Disjunction: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], TypeAlias<"PrerequisitesDisjunction", Object<{
-                        list: import("tsondb/schema/def").MemberDecl<Array<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", Type>>>, true>;
-                        display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DisplayOption", {
-                            Hide: EnumCase<null>;
-                            ReplaceWith: EnumCase<IncludeIdentifier<[], TypeAlias<"ReplacementDisplayOption", Object<{
-                                sentence_type: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"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<String, true>;
-                                }>, true>;
-                            }>, []>>>;
-                        }, []>>, false>;
-                    }>, [T: import("tsondb/schema/def").TypeParameter<"T", Type>]>>>;
-                    Group: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], TypeAlias<"PrerequisiteGroup", Object<{
-                        list: import("tsondb/schema/def").MemberDecl<Array<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", Type>>>, true>;
-                        translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"PrerequisiteGroupTranslation", {
-                            text: import("tsondb/schema/def").MemberDecl<String, true>;
-                        }>, true>;
-                    }>, [T: import("tsondb/schema/def").TypeParameter<"T", Type>]>>>;
-                }, [T: import("tsondb/schema/def").TypeParameter<"T", Type>]>>, true>;
-            }>, [T: import("tsondb/schema/def").TypeParameter<"T", Type>]>>>, [T: import("tsondb/schema/def").TypeParameter<"T", Type>]>>, []>>, false>;
-            binding_cost: import("tsondb/schema/def").MemberDecl<Integer, false>;
-            ap_value: import("tsondb/schema/def").MemberDecl<Integer, false>;
-            src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PublicationRefs", Array<IncludeIdentifier<[], TypeAlias<"PublicationRef", Object<{
-                id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-                occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<string, {
-                    initial: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"InitialOccurrence", Object<{
-                        printing: import("tsondb/schema/def").MemberDecl<Integer, false>;
-                        pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
-                            first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
-                                InsideCoverFront: EnumCase<null>;
-                                InsideCoverBack: EnumCase<null>;
-                                Numbered: EnumCase<Integer>;
-                            }, []>>, true>;
-                            last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
-                                InsideCoverFront: EnumCase<null>;
-                                InsideCoverBack: EnumCase<null>;
-                                Numbered: EnumCase<Integer>;
-                            }, []>>, false>;
-                        }>, []>>>, true>;
-                    }>, []>>, true>;
-                    revisions: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], Enum<"Revision", {
-                        Since: EnumCase<IncludeIdentifier<[], TypeAlias<"Since", Object<{
-                            printing: import("tsondb/schema/def").MemberDecl<Integer, true>;
-                            pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
-                                first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
-                                    InsideCoverFront: EnumCase<null>;
-                                    InsideCoverBack: EnumCase<null>;
-                                    Numbered: EnumCase<Integer>;
-                                }, []>>, true>;
-                                last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
-                                    InsideCoverFront: EnumCase<null>;
-                                    InsideCoverBack: EnumCase<null>;
-                                    Numbered: EnumCase<Integer>;
-                                }, []>>, false>;
-                            }>, []>>>, true>;
-                        }>, []>>>;
-                        Deprecated: EnumCase<IncludeIdentifier<[], TypeAlias<"Deprecation", Object<{
-                            printing: import("tsondb/schema/def").MemberDecl<Integer, true>;
-                        }>, []>>>;
-                    }, []>>>, false>;
-                }>, true>;
-            }>, []>>>, []>>, false>;
-            translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"ExplicitSkillSelectOptionTranslation", {
-                errata: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Errata", Array<IncludeIdentifier<[], TypeAlias<"Erratum", Object<{
-                    date: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").DateType, true>;
-                    description: import("tsondb/schema/def").MemberDecl<String, true>;
-                }>, []>>>, []>>, false>;
-            }>, false>;
-        }>, []>>>;
-        CombatTechnique: EnumCase<IncludeIdentifier<[], TypeAlias<"ExplicitCombatTechniqueSelectOption", Object<{
-            id: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"CombatTechniqueIdentifier", {
-                CloseCombatTechnique: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
-                RangedCombatTechnique: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
-            }, []>>, true>;
-            prerequisites: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"GeneralPrerequisites", IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], TypeAlias<"PrerequisitesForLevels", Array<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], TypeAlias<"PrerequisiteForLevel", Object<{
-                level: import("tsondb/schema/def").MemberDecl<Integer, true>;
-                prerequisite: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], Enum<"PrerequisitesElement", {
-                    Single: EnumCase<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", Type>>>;
-                    Disjunction: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], TypeAlias<"PrerequisitesDisjunction", Object<{
-                        list: import("tsondb/schema/def").MemberDecl<Array<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", Type>>>, true>;
-                        display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DisplayOption", {
-                            Hide: EnumCase<null>;
-                            ReplaceWith: EnumCase<IncludeIdentifier<[], TypeAlias<"ReplacementDisplayOption", Object<{
-                                sentence_type: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"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<String, true>;
-                                }>, true>;
-                            }>, []>>>;
-                        }, []>>, false>;
-                    }>, [T: import("tsondb/schema/def").TypeParameter<"T", Type>]>>>;
-                    Group: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], TypeAlias<"PrerequisiteGroup", Object<{
-                        list: import("tsondb/schema/def").MemberDecl<Array<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", Type>>>, true>;
-                        translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"PrerequisiteGroupTranslation", {
-                            text: import("tsondb/schema/def").MemberDecl<String, true>;
-                        }>, true>;
-                    }>, [T: import("tsondb/schema/def").TypeParameter<"T", Type>]>>>;
-                }, [T: import("tsondb/schema/def").TypeParameter<"T", Type>]>>, true>;
-            }>, [T: import("tsondb/schema/def").TypeParameter<"T", Type>]>>>, [T: import("tsondb/schema/def").TypeParameter<"T", Type>]>>, []>>, false>;
-            binding_cost: import("tsondb/schema/def").MemberDecl<Integer, false>;
-            ap_value: import("tsondb/schema/def").MemberDecl<Integer, false>;
-            src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PublicationRefs", Array<IncludeIdentifier<[], TypeAlias<"PublicationRef", Object<{
-                id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-                occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<string, {
-                    initial: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"InitialOccurrence", Object<{
-                        printing: import("tsondb/schema/def").MemberDecl<Integer, false>;
-                        pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
-                            first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
-                                InsideCoverFront: EnumCase<null>;
-                                InsideCoverBack: EnumCase<null>;
-                                Numbered: EnumCase<Integer>;
-                            }, []>>, true>;
-                            last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
-                                InsideCoverFront: EnumCase<null>;
-                                InsideCoverBack: EnumCase<null>;
-                                Numbered: EnumCase<Integer>;
-                            }, []>>, false>;
-                        }>, []>>>, true>;
-                    }>, []>>, true>;
-                    revisions: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], Enum<"Revision", {
-                        Since: EnumCase<IncludeIdentifier<[], TypeAlias<"Since", Object<{
-                            printing: import("tsondb/schema/def").MemberDecl<Integer, true>;
-                            pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
-                                first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
-                                    InsideCoverFront: EnumCase<null>;
-                                    InsideCoverBack: EnumCase<null>;
-                                    Numbered: EnumCase<Integer>;
-                                }, []>>, true>;
-                                last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
-                                    InsideCoverFront: EnumCase<null>;
-                                    InsideCoverBack: EnumCase<null>;
-                                    Numbered: EnumCase<Integer>;
-                                }, []>>, false>;
-                            }>, []>>>, true>;
-                        }>, []>>>;
-                        Deprecated: EnumCase<IncludeIdentifier<[], TypeAlias<"Deprecation", Object<{
-                            printing: import("tsondb/schema/def").MemberDecl<Integer, true>;
-                        }>, []>>>;
-                    }, []>>>, false>;
-                }>, true>;
-            }>, []>>>, []>>, false>;
-            translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"ExplicitCombatTechniqueSelectOptionTranslation", {
-                errata: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Errata", Array<IncludeIdentifier<[], TypeAlias<"Erratum", Object<{
-                    date: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").DateType, true>;
-                    description: import("tsondb/schema/def").MemberDecl<String, true>;
-                }>, []>>>, []>>, false>;
-            }>, false>;
-        }>, []>>>;
-    }, []>>>, false>;
 }>, []>>, false>;
 export declare const ExplicitSelectOption: Enum<"ExplicitSelectOption", {
     General: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
@@ -1177,6 +1015,194 @@ export declare const GeneralSelectOption: Entity<"GeneralSelectOption", {
         }>, []>>>, []>>, false>;
     }>, true>;
 }, "parent">;
+export declare const explicit_select_options: import("tsondb/schema/def").MemberDecl<ChildEntities<Entity<"GeneralSelectOption", {
+    parent: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"SelectOptionParentIdentifier", {
+        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>;
+        TradeSecret: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+    }, []>>, true>;
+    profession_only: import("tsondb/schema/def").MemberDecl<Boolean, false>;
+    skill_applications: import("tsondb/schema/def").MemberDecl<ChildEntities<Entity<"NewSkillApplication", {
+        parent: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"NewSkillApplicationOrUseParentIdentifier", {
+            GeneralSelectOption: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            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>;
+            BlessedTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            CeremonialItemSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            CombatSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            CombatStyleSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            FatePointSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            GeneralSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            LiturgicalStyleSpecialAbility: 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>;
+            SexSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        }, []>>, true>;
+        skills: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
+        required_skill_rating: import("tsondb/schema/def").MemberDecl<Integer, false>;
+        translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"NewSkillApplicationTranslation", {
+            name: import("tsondb/schema/def").MemberDecl<String, true>;
+        }>, false>;
+    }, "parent">>, true>;
+    skill_uses: import("tsondb/schema/def").MemberDecl<ChildEntities<Entity<"SkillUse", {
+        parent: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"NewSkillApplicationOrUseParentIdentifier", {
+            GeneralSelectOption: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            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>;
+            BlessedTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            CeremonialItemSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            CombatSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            CombatStyleSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            FatePointSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            GeneralSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            LiturgicalStyleSpecialAbility: 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>;
+            SexSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        }, []>>, true>;
+        skills: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
+        required_skill_rating: import("tsondb/schema/def").MemberDecl<Integer, false>;
+        translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"SkillUseTranslation", {
+            name: import("tsondb/schema/def").MemberDecl<String, true>;
+        }>, false>;
+    }, "parent">>, true>;
+    prerequisites: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"GeneralPrerequisites", IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], TypeAlias<"PrerequisitesForLevels", Array<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], TypeAlias<"PrerequisiteForLevel", Object<{
+        level: import("tsondb/schema/def").MemberDecl<Integer, true>;
+        prerequisite: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], Enum<"PrerequisitesElement", {
+            Single: EnumCase<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", Type>>>;
+            Disjunction: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], TypeAlias<"PrerequisitesDisjunction", Object<{
+                list: import("tsondb/schema/def").MemberDecl<Array<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", Type>>>, true>;
+                display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DisplayOption", {
+                    Hide: EnumCase<null>;
+                    ReplaceWith: EnumCase<IncludeIdentifier<[], TypeAlias<"ReplacementDisplayOption", Object<{
+                        sentence_type: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"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<String, true>;
+                        }>, true>;
+                    }>, []>>>;
+                }, []>>, false>;
+            }>, [T: import("tsondb/schema/def").TypeParameter<"T", Type>]>>>;
+            Group: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], TypeAlias<"PrerequisiteGroup", Object<{
+                list: import("tsondb/schema/def").MemberDecl<Array<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", Type>>>, true>;
+                translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"PrerequisiteGroupTranslation", {
+                    text: import("tsondb/schema/def").MemberDecl<String, true>;
+                }>, true>;
+            }>, [T: import("tsondb/schema/def").TypeParameter<"T", Type>]>>>;
+        }, [T: import("tsondb/schema/def").TypeParameter<"T", Type>]>>, true>;
+    }>, [T: import("tsondb/schema/def").TypeParameter<"T", Type>]>>>, [T: import("tsondb/schema/def").TypeParameter<"T", Type>]>>, []>>, false>;
+    binding_cost: import("tsondb/schema/def").MemberDecl<Integer, false>;
+    ap_value: import("tsondb/schema/def").MemberDecl<Integer, false>;
+    src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PublicationRefs", Array<IncludeIdentifier<[], TypeAlias<"PublicationRef", Object<{
+        id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+        occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<string, {
+            initial: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"InitialOccurrence", Object<{
+                printing: import("tsondb/schema/def").MemberDecl<Integer, false>;
+                pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
+                    first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                        InsideCoverFront: EnumCase<null>;
+                        InsideCoverBack: EnumCase<null>;
+                        Numbered: EnumCase<Integer>;
+                    }, []>>, true>;
+                    last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                        InsideCoverFront: EnumCase<null>;
+                        InsideCoverBack: EnumCase<null>;
+                        Numbered: EnumCase<Integer>;
+                    }, []>>, false>;
+                }>, []>>>, true>;
+            }>, []>>, true>;
+            revisions: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], Enum<"Revision", {
+                Since: EnumCase<IncludeIdentifier<[], TypeAlias<"Since", Object<{
+                    printing: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                    pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
+                        first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                            InsideCoverFront: EnumCase<null>;
+                            InsideCoverBack: EnumCase<null>;
+                            Numbered: EnumCase<Integer>;
+                        }, []>>, true>;
+                        last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                            InsideCoverFront: EnumCase<null>;
+                            InsideCoverBack: EnumCase<null>;
+                            Numbered: EnumCase<Integer>;
+                        }, []>>, false>;
+                    }>, []>>>, true>;
+                }>, []>>>;
+                Deprecated: EnumCase<IncludeIdentifier<[], TypeAlias<"Deprecation", Object<{
+                    printing: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                }>, []>>>;
+            }, []>>>, false>;
+        }>, true>;
+    }>, []>>>, []>>, false>;
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"GeneralSelectOptionTranslation", {
+        name: import("tsondb/schema/def").MemberDecl<String, true>;
+        name_in_profession: import("tsondb/schema/def").MemberDecl<String, false>;
+        description: import("tsondb/schema/def").MemberDecl<String, false>;
+        errata: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Errata", Array<IncludeIdentifier<[], TypeAlias<"Erratum", Object<{
+            date: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").DateType, true>;
+            description: import("tsondb/schema/def").MemberDecl<String, true>;
+        }>, []>>>, []>>, false>;
+    }>, true>;
+}, "parent">>, true>;
 export declare const rules: import("tsondb/schema/def").MemberDecl<String, true>;
 export declare const effect: import("tsondb/schema/def").MemberDecl<String, true>;
 export declare const usage_type: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"CombatSpecialAbilityUsageType", {

package/lib/types/_Activatable.js

@@ -45,14 +45,10 @@ Note that this is only a full definition of options for simple logic that can be
             comment: `An entry category with optional further configuration. All available entries from the specified categories will be included as separate select options. You can also specify a set of groups that should only be included. Groups not mentioned will be excluded then.`,
             type: IncludeIdentifier(SelectOptionCategory),
         }),
-        explicit: Optional({
-            comment: `A list of explicit select options. If the identifier has a specific type, its entry is the base of this select option, where values defined here override values from the base. Define the \`src\` property if the options are not derived from the rules text of the advantage/disadvantage/special ability but instead are listed in a separate block and/or on a separate page.`,
-            type: Array(IncludeIdentifier(ExplicitSelectOption), { minItems: 1 }),
-        }),
     }, { minProperties: 1 }),
 });
 export const select_options = Optional({
-    comment: `Definitions for possible options for the activatable entry. They can either be derived from entry categories or be defined explicitly. Both can happen as well, but if there is an explicitly defined select option and a derived select option has the same identifier (which may only happen if skill or combat technique identifiers are used for explicit select options), the explicit definition overwrites the derived option.
+    comment: `Definitions for possible options for the activatable entry, derived from entry categories.
 
 Note that this is only a full definition of options for simple logic that can be made explicit using the more detailed configuration for both derived categories and explicit options. There are quite a few entries whose option logic cannot be fully represented here, so that it needs to be implemented manually.`,
     type: IncludeIdentifier(SelectOptions),
@@ -123,6 +119,12 @@ export const GeneralSelectOption = Entity(import.meta.url, {
         localeId: instanceDisplayNameLocaleId,
     }),
 });
+export const explicit_select_options = Required({
+    comment: `Explicit definitions for possible options for the activatable entry.
+
+Note that this is only a full definition of options for simple logic that can be made explicit using the more detailed configuration for both derived categories and explicit options. There are quite a few entries whose option logic cannot be fully represented here, so that it needs to be implemented manually.`,
+    type: ChildEntities(GeneralSelectOption),
+});
 const ExplicitSkillSelectOption = TypeAlias(import.meta.url, {
     name: "ExplicitSkillSelectOption",
     type: () => Object({

package/lib/types/_Prerequisite.d.ts

@@ -347,6 +347,30 @@ export declare const AnimistPowerPrerequisites: TypeAlias<"AnimistPowerPrerequis
         }>, true>;
     }>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>;
 }, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, []>;
+export declare const TribePrerequisites: TypeAlias<"TribePrerequisites", IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PlainPrerequisites", Array<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], import("tsondb/schema/def").EnumDecl<"PrerequisitesElement", {
+    Single: EnumCase<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>;
+    Disjunction: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PrerequisitesDisjunction", Object<{
+        list: import("tsondb/schema/def").MemberDecl<Array<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>, true>;
+        display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"DisplayOption", {
+            Hide: EnumCase<null>;
+            ReplaceWith: EnumCase<IncludeIdentifier<[], TypeAlias<"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<String, true>;
+                }>, true>;
+            }>, []>>>;
+        }, []>>, false>;
+    }>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>;
+    Group: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PrerequisiteGroup", Object<{
+        list: import("tsondb/schema/def").MemberDecl<Array<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>, true>;
+        translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"PrerequisiteGroupTranslation", {
+            text: import("tsondb/schema/def").MemberDecl<String, true>;
+        }>, true>;
+    }>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>;
+}, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, []>;
 export declare const GeodeRitualPrerequisites: TypeAlias<"GeodeRitualPrerequisites", IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PlainPrerequisites", Array<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], import("tsondb/schema/def").EnumDecl<"PrerequisitesElement", {
     Single: EnumCase<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>;
     Disjunction: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PrerequisitesDisjunction", Object<{

package/lib/types/_Prerequisite.js

@@ -4,7 +4,7 @@
 import { Array, EnumCase, GenEnum, GenIncludeIdentifier, GenTypeAlias, IncludeIdentifier, Integer, Object, Optional, Param, Required, String, TypeAlias, TypeArgument, } from "tsondb/schema/def";
 import { NestedTranslationMap } from "./Locale.js";
 import { DisplayOption } from "./prerequisites/DisplayOption.js";
-import { AdvantageDisadvantagePrerequisiteGroup, AnimistPowerPrerequisiteGroup, ArcaneTraditionPrerequisiteGroup, DerivedCharacteristicPrerequisiteGroup, EnhancementPrerequisiteGroup, GeneralPrerequisiteGroup, GeodeRitualPrerequisiteGroup, InfluencePrerequisiteGroup, LanguagePrerequisiteGroup, LiturgyPrerequisiteGroup, PersonalityTraitPrerequisiteGroup, ProfessionPrerequisiteGroup, PublicationPrerequisiteGroup, RulePrerequisiteGroup, SpellworkPrerequisiteGroup, } from "./prerequisites/PrerequisiteGroups.js";
+import { AdvantageDisadvantagePrerequisiteGroup, AnimistPowerPrerequisiteGroup, ArcaneTraditionPrerequisiteGroup, DerivedCharacteristicPrerequisiteGroup, EnhancementPrerequisiteGroup, GeneralPrerequisiteGroup, GeodeRitualPrerequisiteGroup, InfluencePrerequisiteGroup, LanguagePrerequisiteGroup, LiturgyPrerequisiteGroup, PersonalityTraitPrerequisiteGroup, ProfessionPrerequisiteGroup, PublicationPrerequisiteGroup, RulePrerequisiteGroup, SpellworkPrerequisiteGroup, TribePrerequisiteGroup, } from "./prerequisites/PrerequisiteGroups.js";
 const PrerequisiteGroup = GenTypeAlias(import.meta.url, {
     name: "PrerequisiteGroup",
     comment: "A prerequisite group has no influence on validation logic. It serves as a single unit for displaying purposes, where the source uses a prerequisites item that cannot be represented as a single prerequisite.",
@@ -133,6 +133,10 @@ export const AnimistPowerPrerequisites = TypeAlias(import.meta.url, {
     name: "AnimistPowerPrerequisites",
     type: () => GenIncludeIdentifier(PlainPrerequisites, [IncludeIdentifier(AnimistPowerPrerequisiteGroup)]),
 });
+export const TribePrerequisites = TypeAlias(import.meta.url, {
+    name: "TribePrerequisites",
+    type: () => GenIncludeIdentifier(PlainPrerequisites, [IncludeIdentifier(TribePrerequisiteGroup)]),
+});
 export const GeodeRitualPrerequisites = TypeAlias(import.meta.url, {
     name: "GeodeRitualPrerequisites",
     type: () => GenIncludeIdentifier(PlainPrerequisites, [IncludeIdentifier(GeodeRitualPrerequisiteGroup)]),