optolith-database-schema 0.18.9 → 0.18.12

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.12](https://github.com/elyukai/optolith-database-schema/compare/v0.18.11...v0.18.12) (2025-10-17)
+
+
+### Bug Fixes
+
+* allow single range as a possible book cost value ([4e60943](https://github.com/elyukai/optolith-database-schema/commit/4e60943174213defe3ad006f64b18c359cc86469))
+
+## [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)
 
 

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/_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: () => ({