optolith-database-schema 0.18.8 → 0.18.11

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [0.18.11](https://github.com/elyukai/optolith-database-schema/compare/v0.18.10...v0.18.11) (2025-10-17)
+
+
+### Bug Fixes
+
+* duplicate DefiniteBookCostVariant identifier ([3735381](https://github.com/elyukai/optolith-database-schema/commit/373538121fecbae58dfb02d782d23bbdc9a17029))
+
+## [0.18.10](https://github.com/elyukai/optolith-database-schema/compare/v0.18.9...v0.18.10) (2025-10-17)
+
+
+### Features
+
+* books may have multiple cost values dependending on the edition or other factors ([bd4507d](https://github.com/elyukai/optolith-database-schema/commit/bd4507d2507e01e363dad831a50f87e691ed6087))
+* trade secrets and activatable entries can have an adventure points value that is based on the number of active instances ([c575ec1](https://github.com/elyukai/optolith-database-schema/commit/c575ec11f7326902348956971bea73cf7e9b2cb9))
+* trade secrets can have explicit select options ([48e5d3f](https://github.com/elyukai/optolith-database-schema/commit/48e5d3f8c688733227a8de5cc629b3878f949fcf))
+
+## [0.18.9](https://github.com/elyukai/optolith-database-schema/compare/v0.18.8...v0.18.9) (2025-10-15)
+
+
+### Features
+
+* add alternative rule and player type entities ([034a2ed](https://github.com/elyukai/optolith-database-schema/commit/034a2ed6849a5581951fe1757c5c7179509f76bd))
+
 ## [0.18.8](https://github.com/elyukai/optolith-database-schema/compare/v0.18.7...v0.18.8) (2025-10-14)
 
 ## [0.18.7](https://github.com/elyukai/optolith-database-schema/compare/v0.18.6...v0.18.7) (2025-10-14)

package/lib/main.js

@@ -76,7 +76,7 @@ import { Weapon } from "./types/equipment/item/Weapon.js";
 import { WeaponAccessory } from "./types/equipment/item/WeaponAccessory.js";
 import { ArmorType } from "./types/equipment/item/sub/ArmorType.js";
 import { Reach } from "./types/equipment/item/sub/Reach.js";
-import { ClothingPackage, Laboratory } from "./types/index.js";
+import { AlternativeRule, ClothingPackage, Laboratory, PlayerType } from "./types/index.js";
 import { AnimistPower } from "./types/magicalActions/AnimistPower.js";
 import { Tribe } from "./types/magicalActions/AnimistPower_Tribe.js";
 import { Curse } from "./types/magicalActions/Curse.js";
@@ -154,6 +154,7 @@ export const schema = Schema([
     AdvancedMagicalSpecialAbility,
     AdvancedSkillSpecialAbility,
     Advantage,
+    AlternativeRule,
     Ammunition,
     AncestorGlyph,
     AnimalCare,
@@ -255,6 +256,7 @@ export const schema = Schema([
     PatronCategory,
     Patron,
     PersonalityTrait,
+    PlayerType,
     Poison,
     Profession,
     Property,

package/lib/types/Advantage.d.ts

@@ -861,6 +861,16 @@ export declare const Advantage: Entity<"Advantage", {
                 replacement: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, false>;
             }>, false>;
         }>, []>>>;
+        DependingOnActiveInstances: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstances", {
+            Threshold: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"AdventurePointsDependingOnActiveInstancesThreshold", Object<{
+                normal: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+                threshold: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+                alternative: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+            }>, []>>>;
+            Multiplier: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"AdventurePointsDependingOnActiveInstancesMultiplier", Object<{
+                base: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+            }>, []>>>;
+        }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;
     }, []>>, true>;
     has_maximum_spent_influence: import("tsondb/schema/def").MemberDecl<Boolean, true>;

package/lib/types/Disadvantage.d.ts

@@ -861,6 +861,16 @@ export declare const Disadvantage: Entity<"Disadvantage", {
                 replacement: import("tsondb/schema/def").MemberDecl<String, false>;
             }>, false>;
         }>, []>>>;
+        DependingOnActiveInstances: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstances", {
+            Threshold: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"AdventurePointsDependingOnActiveInstancesThreshold", Object<{
+                normal: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+                threshold: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+                alternative: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+            }>, []>>>;
+            Multiplier: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"AdventurePointsDependingOnActiveInstancesMultiplier", Object<{
+                base: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+            }>, []>>>;
+        }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;
     }, []>>, true>;
     has_maximum_spent_influence: import("tsondb/schema/def").MemberDecl<Boolean, true>;

package/lib/types/_Activatable.d.ts

@@ -828,8 +828,172 @@ export declare const select_options: import("tsondb/schema/def").MemberDecl<Incl
         }>, []>>>;
     }, []>>>, false>;
 }>, []>>, false>;
+export declare const ExplicitSelectOption: 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>;
+        skill_applications: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"NewSkillApplications", Array<import("tsondb/schema/def").ReferenceIdentifierType>, []>>, false>;
+        skill_uses: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"SkillUses", Array<import("tsondb/schema/def").ReferenceIdentifierType>, []>>, false>;
+        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>;
+    }>, []>>>;
+}, []>;
 export declare const GeneralSelectOption: Entity<"GeneralSelectOption", {
-    parent: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"ActivatableIdentifier", {
+    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>;
@@ -880,6 +1044,7 @@ export declare const GeneralSelectOption: Entity<"GeneralSelectOption", {
         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<IncludeIdentifier<[], TypeAlias<"NewSkillApplications", Array<import("tsondb/schema/def").ReferenceIdentifierType>, []>>, false>;
@@ -1595,8 +1760,29 @@ export declare const ap_value: import("tsondb/schema/def").MemberDecl<IncludeIde
             replacement: import("tsondb/schema/def").MemberDecl<String, false>;
         }>, false>;
     }>, []>>>;
+    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>;
+        }>, []>>>;
+        Multiplier: EnumCase<IncludeIdentifier<[], TypeAlias<"AdventurePointsDependingOnActiveInstancesMultiplier", Object<{
+            base: import("tsondb/schema/def").MemberDecl<Integer, true>;
+        }>, []>>>;
+    }, []>>>;
     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 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>;
+    }>, []>>>;
+    Multiplier: EnumCase<IncludeIdentifier<[], TypeAlias<"AdventurePointsDependingOnActiveInstancesMultiplier", Object<{
+        base: import("tsondb/schema/def").MemberDecl<Integer, true>;
+    }>, []>>>;
+}, []>;
 export declare const input: import("tsondb/schema/def").MemberDecl<String, false>;

package/lib/types/_Activatable.js

@@ -6,7 +6,7 @@ import { NestedTranslationMap } from "./Locale.js";
 import { SelectOptionCategory } from "./_ActivatableSelectOptionCategory.js";
 import { DurationUnitValue } from "./_ActivatableSkillDuration.js";
 import { AspectIdentifier, CloseCombatTechniqueIdentifier, GeneralIdentifier, MagicalTraditionIdentifier, NewSkillApplicationIdentifier, PatronIdentifier, PropertyIdentifier, RaceIdentifier, RangedCombatTechniqueIdentifier, SkillIdentifier, SkillUseIdentifier, WeaponIdentifier, } from "./_Identifier.js";
-import { ActivatableIdentifier, AdvancedSpecialAbilityRestrictedOptionIdentifier, CombatRelatedSpecialAbilityIdentifier, CombatTechniqueIdentifier, NewSkillApplicationOrUseParentIdentifier, VolumePointsOptionReferenceIdentifier, } from "./_IdentifierGroup.js";
+import { AdvancedSpecialAbilityRestrictedOptionIdentifier, CombatRelatedSpecialAbilityIdentifier, CombatTechniqueIdentifier, NewSkillApplicationOrUseParentIdentifier, SelectOptionParentIdentifier, VolumePointsOptionReferenceIdentifier, } from "./_IdentifierGroup.js";
 import { GeneralPrerequisites } from "./_Prerequisite.js";
 import { ResponsiveText, ResponsiveTextOptional } from "./_ResponsiveText.js";
 import { DisplayOption } from "./prerequisites/DisplayOption.js";
@@ -56,7 +56,7 @@ export const select_options = Optional({
 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),
 });
-const ExplicitSelectOption = Enum(import.meta.url, {
+export const ExplicitSelectOption = Enum(import.meta.url, {
     name: "ExplicitSelectOption",
     values: () => ({
         General: EnumCase({ type: GeneralIdentifier() }),
@@ -70,7 +70,7 @@ export const GeneralSelectOption = Entity(import.meta.url, {
     type: () => Object({
         parent: Required({
             comment: "The entry that contains select option.",
-            type: IncludeIdentifier(ActivatableIdentifier),
+            type: IncludeIdentifier(SelectOptionParentIdentifier),
         }),
         profession_only: Optional({
             comment: "Sometimes, professions use specific text selections that are not contained in described lists. This ensures you can use them for professions only. They are not going to be displayed as options to the user.",
@@ -1345,6 +1345,9 @@ const AdventurePointsValue = Enum(import.meta.url, {
         DerivedFromSelection: EnumCase({
             type: IncludeIdentifier(AdventurePointsDerivedFromSelection),
         }),
+        DependingOnActiveInstances: EnumCase({
+            type: IncludeIdentifier(AdventurePointsDependingOnActiveInstances),
+        }),
         Indefinite: EnumCase({ type: null }),
     }),
 });
@@ -1362,7 +1365,7 @@ export const ap_value_append = Optional({
     isDeprecated: true,
     type: String({ minLength: 1 }),
 });
-const FixedAdventurePointsValue = TypeAlias(import.meta.url, {
+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),
@@ -1389,6 +1392,46 @@ const AdventurePointsSingleValue = TypeAlias(import.meta.url, {
     comment: "A single adventure points value.",
     type: () => Integer({ minimum: 0 }),
 });
+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),
+        }),
+        Multiplier: EnumCase({
+            type: IncludeIdentifier(AdventurePointsDependingOnActiveInstancesMultiplier),
+        }),
+    }),
+});
+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 AdventurePointsDependingOnActiveInstancesMultiplier = TypeAlias(import.meta.url, {
+    name: "AdventurePointsDependingOnActiveInstancesMultiplier",
+    comment: "The adventure points cost depends on how many instances of the entry are already active.",
+    type: () => Object({
+        base: Required({
+            comment: "The base adventure points value that is multiplied by `(number of active instances) + 1`.",
+            type: Integer({ minimum: 0 }),
+        }),
+    }),
+});
 export const input = Optional({
     comment: "A string that is used as a label for an input field.",
     type: String({ minLength: 1 }),

package/lib/types/_Identifier.d.ts

@@ -4,6 +4,7 @@ export declare const AdvancedKarmaSpecialAbilityIdentifier: () => R;
 export declare const AdvancedMagicalSpecialAbilityIdentifier: () => R;
 export declare const AdvancedSkillSpecialAbilityIdentifier: () => R;
 export declare const AdvantageIdentifier: () => R;
+export declare const AlternativeRuleIdentifier: () => R;
 export declare const AmmunitionIdentifier: () => R;
 export declare const AncestorGlyphIdentifier: () => R;
 export declare const AnimalCareIdentifier: () => R;
@@ -107,6 +108,7 @@ export declare const PactTypeIdentifier: () => R;
 export declare const PatronCategoryIdentifier: () => R;
 export declare const PatronIdentifier: () => R;
 export declare const PersonalityTraitIdentifier: () => R;
+export declare const PlayerTypeIdentifier: () => R;
 export declare const PoisonIdentifier: () => R;
 export declare const ProfessionIdentifier: () => R;
 export declare const ProfessionPackageIdentifier: () => R;

package/lib/types/_Identifier.js

@@ -75,6 +75,8 @@ import { Profession, ProfessionPackage, ProfessionVariant, ProfessionVersion, }
 import { Property } from "./Property.js";
 import { Race, RaceVariant } from "./Race.js";
 import { Ritual } from "./Ritual.js";
+import { AlternativeRule } from "./rule/AlternativeRule.js";
+import { PlayerType } from "./rule/AlternativeRule_PlayerType.js";
 import { CoreRule } from "./rule/CoreRule.js";
 import { FocusRule } from "./rule/FocusRule.js";
 import { Subject } from "./rule/FocusRule_Subject.js";
@@ -148,6 +150,7 @@ export const AdvancedKarmaSpecialAbilityIdentifier = () => R(AdvancedKarmaSpecia
 export const AdvancedMagicalSpecialAbilityIdentifier = () => R(AdvancedMagicalSpecialAbility);
 export const AdvancedSkillSpecialAbilityIdentifier = () => R(AdvancedSkillSpecialAbility);
 export const AdvantageIdentifier = () => R(Advantage);
+export const AlternativeRuleIdentifier = () => R(AlternativeRule);
 export const AmmunitionIdentifier = () => R(Ammunition);
 export const AncestorGlyphIdentifier = () => R(AncestorGlyph);
 export const AnimalCareIdentifier = () => R(AnimalCare);
@@ -251,6 +254,7 @@ export const PactTypeIdentifier = () => R(PactType);
 export const PatronCategoryIdentifier = () => R(PatronCategory);
 export const PatronIdentifier = () => R(Patron);
 export const PersonalityTraitIdentifier = () => R(PersonalityTrait);
+export const PlayerTypeIdentifier = () => R(PlayerType);
 export const PoisonIdentifier = () => R(Poison);
 export const ProfessionIdentifier = () => R(Profession);
 export const ProfessionPackageIdentifier = () => R(ProfessionPackage);

package/lib/types/_IdentifierGroup.d.ts

@@ -224,6 +224,59 @@ export declare const SelectOptionIdentifier: Enum<"SelectOptionIdentifier", {
     TargetCategory: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
     Patron: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
 }, []>;
+export declare const SelectOptionParentIdentifier: 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>;
+}, []>;
 export declare const RequirableSelectOptionIdentifier: Enum<"RequirableSelectOptionIdentifier", {
     General: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
     Skill: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;

package/lib/types/_IdentifierGroup.js

@@ -277,6 +277,64 @@ export const SelectOptionIdentifier = Enum(import.meta.url, {
         Patron: EnumCase({ type: PatronIdentifier() }),
     }),
 });
+export const SelectOptionParentIdentifier = Enum(import.meta.url, {
+    name: "SelectOptionParentIdentifier",
+    values: () => ({
+        Advantage: EnumCase({ type: AdvantageIdentifier() }),
+        Disadvantage: EnumCase({ type: DisadvantageIdentifier() }),
+        AdvancedCombatSpecialAbility: EnumCase({ type: AdvancedCombatSpecialAbilityIdentifier() }),
+        AdvancedKarmaSpecialAbility: EnumCase({ type: AdvancedKarmaSpecialAbilityIdentifier() }),
+        AdvancedMagicalSpecialAbility: EnumCase({ type: AdvancedMagicalSpecialAbilityIdentifier() }),
+        AdvancedSkillSpecialAbility: EnumCase({ type: AdvancedSkillSpecialAbilityIdentifier() }),
+        AncestorGlyph: EnumCase({ type: AncestorGlyphIdentifier() }),
+        ArcaneOrbEnchantment: EnumCase({ type: ArcaneOrbEnchantmentIdentifier() }),
+        AttireEnchantment: EnumCase({ type: AttireEnchantmentIdentifier() }),
+        BlessedTradition: EnumCase({ type: BlessedTraditionIdentifier() }),
+        BowlEnchantment: EnumCase({ type: BowlEnchantmentIdentifier() }),
+        BrawlingSpecialAbility: EnumCase({ type: BrawlingSpecialAbilityIdentifier() }),
+        CauldronEnchantment: EnumCase({ type: CauldronEnchantmentIdentifier() }),
+        CeremonialItemSpecialAbility: EnumCase({ type: CeremonialItemSpecialAbilityIdentifier() }),
+        ChronicleEnchantment: EnumCase({ type: ChronicleEnchantmentIdentifier() }),
+        CombatSpecialAbility: EnumCase({ type: CombatSpecialAbilityIdentifier() }),
+        CombatStyleSpecialAbility: EnumCase({ type: CombatStyleSpecialAbilityIdentifier() }),
+        CommandSpecialAbility: EnumCase({ type: CommandSpecialAbilityIdentifier() }),
+        DaggerRitual: EnumCase({ type: DaggerRitualIdentifier() }),
+        FamiliarSpecialAbility: EnumCase({ type: FamiliarSpecialAbilityIdentifier() }),
+        FatePointSexSpecialAbility: EnumCase({ type: FatePointSexSpecialAbilityIdentifier() }),
+        FatePointSpecialAbility: EnumCase({ type: FatePointSpecialAbilityIdentifier() }),
+        FoolsHatEnchantment: EnumCase({ type: FoolsHatEnchantmentIdentifier() }),
+        GeneralSpecialAbility: EnumCase({ type: GeneralSpecialAbilityIdentifier() }),
+        InstrumentEnchantment: EnumCase({ type: InstrumentEnchantmentIdentifier() }),
+        KarmaSpecialAbility: EnumCase({ type: KarmaSpecialAbilityIdentifier() }),
+        Krallenkettenzauber: EnumCase({ type: KrallenkettenzauberIdentifier() }),
+        LiturgicalStyleSpecialAbility: EnumCase({ type: LiturgicalStyleSpecialAbilityIdentifier() }),
+        LycantropicGift: EnumCase({ type: LycantropicGiftIdentifier() }),
+        MagicalSign: EnumCase({ type: MagicalSignIdentifier() }),
+        MagicalSpecialAbility: EnumCase({ type: MagicalSpecialAbilityIdentifier() }),
+        MagicalTradition: EnumCase({ type: MagicalTraditionIdentifier() }),
+        MagicStyleSpecialAbility: EnumCase({ type: MagicStyleSpecialAbilityIdentifier() }),
+        OrbEnchantment: EnumCase({ type: OrbEnchantmentIdentifier() }),
+        PactGift: EnumCase({ type: PactGiftIdentifier() }),
+        ProtectiveWardingCircleSpecialAbility: EnumCase({
+            type: ProtectiveWardingCircleSpecialAbilityIdentifier(),
+        }),
+        RingEnchantment: EnumCase({ type: RingEnchantmentIdentifier() }),
+        Sermon: EnumCase({ type: SermonIdentifier() }),
+        SexSpecialAbility: EnumCase({ type: SexSpecialAbilityIdentifier() }),
+        SickleRitual: EnumCase({ type: SickleRitualIdentifier() }),
+        SikaryanDrainSpecialAbility: EnumCase({ type: SikaryanDrainSpecialAbilityIdentifier() }),
+        SkillStyleSpecialAbility: EnumCase({ type: SkillStyleSpecialAbilityIdentifier() }),
+        SpellSwordEnchantment: EnumCase({ type: SpellSwordEnchantmentIdentifier() }),
+        StaffEnchantment: EnumCase({ type: StaffEnchantmentIdentifier() }),
+        ToyEnchantment: EnumCase({ type: ToyEnchantmentIdentifier() }),
+        Trinkhornzauber: EnumCase({ type: TrinkhornzauberIdentifier() }),
+        VampiricGift: EnumCase({ type: VampiricGiftIdentifier() }),
+        Vision: EnumCase({ type: VisionIdentifier() }),
+        WandEnchantment: EnumCase({ type: WandEnchantmentIdentifier() }),
+        WeaponEnchantment: EnumCase({ type: WeaponEnchantmentIdentifier() }),
+        TradeSecret: EnumCase({ type: TradeSecretIdentifier() }),
+    }),
+});
 export const RequirableSelectOptionIdentifier = Enum(import.meta.url, {
     name: "RequirableSelectOptionIdentifier",
     values: () => ({