optolith-database-schema 0.18.11 → 0.18.13

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 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.13](https://github.com/elyukai/optolith-database-schema/compare/v0.18.12...v0.18.13) (2025-10-17)
+
+
+### Features
+
+* add options for adventure point multiplier expression ([7898b2d](https://github.com/elyukai/optolith-database-schema/commit/7898b2da788e386e74f75b9883638026900b3e95))
+
+## [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)
 
 

package/lib/types/Advantage.d.ts

@@ -869,6 +869,10 @@ export declare const Advantage: Entity<"Advantage", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/Disadvantage.d.ts

@@ -869,6 +869,10 @@ export declare const Disadvantage: Entity<"Disadvantage", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/_Activatable.d.ts

@@ -1768,6 +1768,10 @@ export declare const ap_value: import("tsondb/schema/def").MemberDecl<IncludeIde
         }>, []>>>;
         Multiplier: EnumCase<IncludeIdentifier<[], TypeAlias<"AdventurePointsDependingOnActiveInstancesMultiplier", Object<{
             base: import("tsondb/schema/def").MemberDecl<Integer, true>;
+            expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                Linear: EnumCase<null>;
+                Exponentiation: EnumCase<null>;
+            }, []>>, true>;
         }>, []>>>;
     }, []>>>;
     Indefinite: EnumCase<null>;
@@ -1783,6 +1787,10 @@ export declare const AdventurePointsDependingOnActiveInstances: Enum<"AdventureP
     }>, []>>>;
     Multiplier: EnumCase<IncludeIdentifier<[], TypeAlias<"AdventurePointsDependingOnActiveInstancesMultiplier", Object<{
         base: import("tsondb/schema/def").MemberDecl<Integer, true>;
+        expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+            Linear: EnumCase<null>;
+            Exponentiation: EnumCase<null>;
+        }, []>>, true>;
     }>, []>>>;
 }, []>;
 export declare const input: import("tsondb/schema/def").MemberDecl<String, false>;

package/lib/types/_Activatable.js

@@ -1427,9 +1427,29 @@ const AdventurePointsDependingOnActiveInstancesMultiplier = TypeAlias(import.met
     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`.",
+            comment: "The base adventure points value that is multiplied by the result of the selected expression.",
             type: Integer({ minimum: 0 }),
         }),
+        expression: Required({
+            comment: "The type of expression to use for calculating the multiplier.",
+            type: IncludeIdentifier(AdventurePointsDependingOnActiveInstancesMultiplierExpression),
+        }),
+    }),
+});
+const AdventurePointsDependingOnActiveInstancesMultiplierExpression = Enum(import.meta.url, {
+    name: "AdventurePointsDependingOnActiveInstancesMultiplierExpression",
+    comment: `The type of expression to use for calculating the multiplier that is multiplied with the base value to get the final AP value.
+
+To keep the comments for each case easier to compare, the variable \`active\` is used for the number of active instances.`,
+    values: () => ({
+        Linear: EnumCase({
+            comment: "active − 1",
+            type: null,
+        }),
+        Exponentiation: EnumCase({
+            comment: "2^active^",
+            type: null,
+        }),
     }),
 });
 export const input = Optional({

package/lib/types/equipment/item/Book.d.ts

@@ -1,8 +1,25 @@
-import { Array, Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, String, TypeAlias } from "tsondb/schema/def";
+import { Array, Entity, Enum, EnumCase, IncludeIdentifier, Object, String, TypeAlias } from "tsondb/schema/def";
 export declare const Book: Entity<"Book", {
     cost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"BookCost", {
-        Constant: EnumCase<Integer>;
-        Variable: EnumCase<Array<IncludeIdentifier<[], Enum<"BookCostVariant", {
+        Single: EnumCase<IncludeIdentifier<[], Enum<"Cost", {
+            Free: EnumCase<null>;
+            Various: EnumCase<null>;
+            Invaluable: EnumCase<null>;
+            Fixed: EnumCase<IncludeIdentifier<[], TypeAlias<"FixedCost", Object<{
+                value: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").FloatType, true>;
+                translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"FixedCostTranslation", {
+                    wrap_in_text: import("tsondb/schema/def").MemberDecl<String, true>;
+                }>, false>;
+            }>, []>>>;
+            Range: EnumCase<IncludeIdentifier<[], TypeAlias<"CostRange", Object<{
+                from: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").FloatType, true>;
+                to: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").FloatType, true>;
+                translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"CostRangeTranslation", {
+                    wrap_in_text: import("tsondb/schema/def").MemberDecl<String, true>;
+                }>, false>;
+            }>, []>>>;
+        }, []>>>;
+        Multiple: EnumCase<Array<IncludeIdentifier<[], Enum<"BookCostVariant", {
             Definite: EnumCase<IncludeIdentifier<[], TypeAlias<"DefiniteBookCostVariant", Object<{
                 cost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Cost", {
                     Free: EnumCase<null>;
@@ -39,48 +56,48 @@ export declare const Book: Entity<"Book", {
         Primitive: EnumCase<null>;
         Simple: EnumCase<null>;
         Complex: EnumCase<IncludeIdentifier<[], TypeAlias<"ComplexComplexity", Object<{
-            ap_value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+            ap_value: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
         }>, []>>>;
     }, []>>, false>;
     structure_points: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"StructurePoints", Array<IncludeIdentifier<[], TypeAlias<"StructurePointsComponent", Object<{
-        points: import("tsondb/schema/def").MemberDecl<Integer, true>;
+        points: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
     }>, []>>>, []>>, 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>;
+                printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, 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>;
+                        Numbered: EnumCase<import("tsondb/schema/def").IntegerType>;
                     }, []>>, true>;
                     last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
                         InsideCoverFront: EnumCase<null>;
                         InsideCoverBack: EnumCase<null>;
-                        Numbered: EnumCase<Integer>;
+                        Numbered: EnumCase<import("tsondb/schema/def").IntegerType>;
                     }, []>>, 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>;
+                    printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, 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>;
+                            Numbered: EnumCase<import("tsondb/schema/def").IntegerType>;
                         }, []>>, true>;
                         last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
                             InsideCoverFront: EnumCase<null>;
                             InsideCoverBack: EnumCase<null>;
-                            Numbered: EnumCase<Integer>;
+                            Numbered: EnumCase<import("tsondb/schema/def").IntegerType>;
                         }, []>>, false>;
                     }>, []>>>, true>;
                 }>, []>>>;
                 Deprecated: EnumCase<IncludeIdentifier<[], TypeAlias<"Deprecation", Object<{
-                    printing: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                    printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
                 }>, []>>>;
             }, []>>>, false>;
         }>, true>;

package/lib/types/equipment/item/Book.js

@@ -1,4 +1,4 @@
-import { Array, Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
+import { Array, Entity, Enum, EnumCase, IncludeIdentifier, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
 import { NestedTranslationMap } from "../../Locale.js";
 import { Errata } from "../../source/_Erratum.js";
 import { src } from "../../source/_PublicationRef.js";
@@ -58,12 +58,13 @@ export const Book = Entity(import.meta.url, {
 });
 const BookCost = Enum(import.meta.url, {
     name: "BookCost",
+    comment: "The cost of the book, which may be a single value or multiple values that are defined by specific editions or other defining factors of the book.",
     values: () => ({
-        Constant: EnumCase({
-            comment: "The book has a fixed cost.",
-            type: Integer({ minimum: 0 }),
+        Single: EnumCase({
+            comment: "The book only has a single cost description.",
+            type: IncludeIdentifier(Cost),
         }),
-        Variable: EnumCase({
+        Multiple: EnumCase({
             comment: "The book’s cost varies by edition or other factors.",
             type: Array(IncludeIdentifier(BookCostVariant), { minItems: 2 }),
         }),

package/lib/types/specialAbility/AdvancedCombatSpecialAbility.d.ts

@@ -986,6 +986,10 @@ export declare const AdvancedCombatSpecialAbility: Entity<"AdvancedCombatSpecial
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/AdvancedKarmaSpecialAbility.d.ts

@@ -869,6 +869,10 @@ export declare const AdvancedKarmaSpecialAbility: Entity<"AdvancedKarmaSpecialAb
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/AdvancedMagicalSpecialAbility.d.ts

@@ -869,6 +869,10 @@ export declare const AdvancedMagicalSpecialAbility: Entity<"AdvancedMagicalSpeci
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/AdvancedSkillSpecialAbility.d.ts

@@ -869,6 +869,10 @@ export declare const AdvancedSkillSpecialAbility: Entity<"AdvancedSkillSpecialAb
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/AncestorGlyph.d.ts

@@ -868,6 +868,10 @@ export declare const AncestorGlyph: Entity<"AncestorGlyph", {
             }>, []>>>;
             Multiplier: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"AdventurePointsDependingOnActiveInstancesMultiplier", Object<{
                 base: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/BlessedTradition.d.ts

@@ -896,6 +896,10 @@ export declare const BlessedTradition: Entity<"BlessedTradition", {
             }>, []>>>;
             Multiplier: EnumCase<IncludeIdentifier<[], TypeAlias<"AdventurePointsDependingOnActiveInstancesMultiplier", Object<{
                 base: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: EnumCase<null>;
+                    Exponentiation: EnumCase<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: EnumCase<null>;

package/lib/types/specialAbility/BrawlingSpecialAbility.d.ts

@@ -932,6 +932,10 @@ export declare const BrawlingSpecialAbility: Entity<"BrawlingSpecialAbility", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/CeremonialItemSpecialAbility.d.ts

@@ -870,6 +870,10 @@ export declare const CeremonialItemSpecialAbility: Entity<"CeremonialItemSpecial
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/CombatSpecialAbility.d.ts

@@ -986,6 +986,10 @@ export declare const CombatSpecialAbility: Entity<"CombatSpecialAbility", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/CombatStyleSpecialAbility.d.ts

@@ -987,6 +987,10 @@ export declare const CombatStyleSpecialAbility: Entity<"CombatStyleSpecialAbilit
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/CommandSpecialAbility.d.ts

@@ -932,6 +932,10 @@ export declare const CommandSpecialAbility: Entity<"CommandSpecialAbility", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/FamiliarSpecialAbility.d.ts

@@ -867,6 +867,10 @@ export declare const FamiliarSpecialAbility: Entity<"FamiliarSpecialAbility", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/FatePointSexSpecialAbility.d.ts

@@ -867,6 +867,10 @@ export declare const FatePointSexSpecialAbility: Entity<"FatePointSexSpecialAbil
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/FatePointSpecialAbility.d.ts

@@ -869,6 +869,10 @@ export declare const FatePointSpecialAbility: Entity<"FatePointSpecialAbility",
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/GeneralSpecialAbility.d.ts

@@ -869,6 +869,10 @@ export declare const GeneralSpecialAbility: Entity<"GeneralSpecialAbility", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/KarmaSpecialAbility.d.ts

@@ -867,6 +867,10 @@ export declare const KarmaSpecialAbility: Entity<"KarmaSpecialAbility", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/LiturgicalStyleSpecialAbility.d.ts

@@ -918,6 +918,10 @@ export declare const LiturgicalStyleSpecialAbility: Entity<"LiturgicalStyleSpeci
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/LycantropicGift.d.ts

@@ -867,6 +867,10 @@ export declare const LycantropicGift: Entity<"LycantropicGift", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/MagicStyleSpecialAbility.d.ts

@@ -918,6 +918,10 @@ export declare const MagicStyleSpecialAbility: Entity<"MagicStyleSpecialAbility"
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/MagicalSpecialAbility.d.ts

@@ -869,6 +869,10 @@ export declare const MagicalSpecialAbility: Entity<"MagicalSpecialAbility", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/MagicalTradition.d.ts

@@ -882,6 +882,10 @@ export declare const MagicalTradition: Entity<"MagicalTradition", {
             }>, []>>>;
             Multiplier: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"AdventurePointsDependingOnActiveInstancesMultiplier", Object<{
                 base: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/PactGift.d.ts

@@ -944,6 +944,10 @@ export declare const PactGift: Entity<"PactGift", {
             }>, []>>>;
             Multiplier: EnumCase<IncludeIdentifier<[], TypeAlias<"AdventurePointsDependingOnActiveInstancesMultiplier", Object<{
                 base: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: EnumCase<null>;
+                    Exponentiation: EnumCase<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: EnumCase<null>;

package/lib/types/specialAbility/ProtectiveWardingCircleSpecialAbility.d.ts

@@ -868,6 +868,10 @@ export declare const ProtectiveWardingCircleSpecialAbility: Entity<"ProtectiveWa
             }>, []>>>;
             Multiplier: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"AdventurePointsDependingOnActiveInstancesMultiplier", Object<{
                 base: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/Sermon.d.ts

@@ -867,6 +867,10 @@ export declare const Sermon: Entity<"Sermon", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/SexSpecialAbility.d.ts

@@ -869,6 +869,10 @@ export declare const SexSpecialAbility: Entity<"SexSpecialAbility", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/SikaryanDrainSpecialAbility.d.ts

@@ -867,6 +867,10 @@ export declare const SikaryanDrainSpecialAbility: Entity<"SikaryanDrainSpecialAb
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/SkillStyleSpecialAbility.d.ts

@@ -916,6 +916,10 @@ export declare const SkillStyleSpecialAbility: Entity<"SkillStyleSpecialAbility"
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/VampiricGift.d.ts

@@ -867,6 +867,10 @@ export declare const VampiricGift: Entity<"VampiricGift", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/Vision.d.ts

@@ -867,6 +867,10 @@ export declare const Vision: Entity<"Vision", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/specialAbility/sub/TradeSecret.d.ts

@@ -176,6 +176,10 @@ export declare const TradeSecret: Entity<"TradeSecret", {
             }>, []>>>;
             Multiplier: EnumCase<IncludeIdentifier<[], TypeAlias<"AdventurePointsDependingOnActiveInstancesMultiplier", Object<{
                 base: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: EnumCase<null>;
+                    Exponentiation: EnumCase<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
     }, []>>, true>;

package/lib/types/traditionArtifacts/ArcaneOrbEnchantment.d.ts

@@ -1090,6 +1090,10 @@ export declare const ArcaneOrbEnchantment: Entity<"ArcaneOrbEnchantment", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/traditionArtifacts/AttireEnchantment.d.ts

@@ -1090,6 +1090,10 @@ export declare const AttireEnchantment: Entity<"AttireEnchantment", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/traditionArtifacts/BowlEnchantment.d.ts

@@ -1090,6 +1090,10 @@ export declare const BowlEnchantment: Entity<"BowlEnchantment", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/traditionArtifacts/CauldronEnchantment.d.ts

@@ -1091,6 +1091,10 @@ export declare const CauldronEnchantment: Entity<"CauldronEnchantment", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/traditionArtifacts/ChronicleEnchantment.d.ts

@@ -1090,6 +1090,10 @@ export declare const ChronicleEnchantment: Entity<"ChronicleEnchantment", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/traditionArtifacts/DaggerRitual.d.ts

@@ -1097,6 +1097,10 @@ export declare const DaggerRitual: Entity<"DaggerRitual", {
             }>, []>>>;
             Multiplier: EnumCase<IncludeIdentifier<[], TypeAlias<"AdventurePointsDependingOnActiveInstancesMultiplier", Object<{
                 base: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: EnumCase<null>;
+                    Exponentiation: EnumCase<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: EnumCase<null>;

package/lib/types/traditionArtifacts/FoolsHatEnchantment.d.ts

@@ -1090,6 +1090,10 @@ export declare const FoolsHatEnchantment: Entity<"FoolsHatEnchantment", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/traditionArtifacts/InstrumentEnchantment.d.ts

@@ -1090,6 +1090,10 @@ export declare const InstrumentEnchantment: Entity<"InstrumentEnchantment", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/traditionArtifacts/Krallenkettenzauber.d.ts

@@ -1090,6 +1090,10 @@ export declare const Krallenkettenzauber: Entity<"Krallenkettenzauber", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/traditionArtifacts/OrbEnchantment.d.ts

@@ -1090,6 +1090,10 @@ export declare const OrbEnchantment: Entity<"OrbEnchantment", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/traditionArtifacts/RingEnchantment.d.ts

@@ -1090,6 +1090,10 @@ export declare const RingEnchantment: Entity<"RingEnchantment", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/traditionArtifacts/SickleRitual.d.ts

@@ -1090,6 +1090,10 @@ export declare const SickleRitual: Entity<"SickleRitual", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/traditionArtifacts/SpellSwordEnchantment.d.ts

@@ -1090,6 +1090,10 @@ export declare const SpellSwordEnchantment: Entity<"SpellSwordEnchantment", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/traditionArtifacts/StaffEnchantment.d.ts

@@ -1090,6 +1090,10 @@ export declare const StaffEnchantment: Entity<"StaffEnchantment", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/traditionArtifacts/ToyEnchantment.d.ts

@@ -1090,6 +1090,10 @@ export declare const ToyEnchantment: Entity<"ToyEnchantment", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/traditionArtifacts/Trinkhornzauber.d.ts

@@ -1090,6 +1090,10 @@ export declare const Trinkhornzauber: Entity<"Trinkhornzauber", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/traditionArtifacts/WandEnchantment.d.ts

@@ -1039,6 +1039,10 @@ export declare const WandEnchantment: Entity<"WandEnchantment", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/lib/types/traditionArtifacts/WeaponEnchantment.d.ts

@@ -1090,6 +1090,10 @@ export declare const WeaponEnchantment: Entity<"WeaponEnchantment", {
             }>, []>>>;
             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>;
+                expression: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdventurePointsDependingOnActiveInstancesMultiplierExpression", {
+                    Linear: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    Exponentiation: import("tsondb/schema/def").EnumCaseDecl<null>;
+                }, []>>, true>;
             }>, []>>>;
         }, []>>>;
         Indefinite: import("tsondb/schema/def").EnumCaseDecl<null>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "optolith-database-schema",
-  "version": "0.18.11",
+  "version": "0.18.13",
   "description": "Definitions and utilities for the flat-file database of Optolith, a character creation tool for the Pen and Paper RPG “The Dark Eye 5”, and its external integrations into other software.",
   "keywords": [
     "tde",