@optolith/database-schema 0.61.0 → 0.63.0

package/lib/types/_ActivatableSkillParameterMap.d.ts

@@ -1,23 +1,11 @@
 import * as DB from "tsondb/schema/dsl";
-export declare const ParameterMap: DB.TypeAlias<"ParameterMap", DB.Object<{
-    options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ParameterMapOption", DB.Object<{
-        value: DB.MemberDecl<DB.TypeArgument<DB.Param<"Value", DB.Type>>, true>;
-        translations: DB.MemberDecl<DB.NestedEntityMap<"ParameterMapOptionTranslation", {
-            label: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
-                full: DB.MemberDecl<DB.String, true>;
-                compressed: DB.MemberDecl<DB.String, false>;
-            }>, []>>, true>;
-            standaloneLabel: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
-                full: DB.MemberDecl<DB.String, true>;
-                compressed: DB.MemberDecl<DB.String, false>;
-            }>, []>>, false>;
-        }>, false>;
-    }>, [Value: DB.Param<"Value", DB.Type>]>>>, true>;
-    style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ParameterMapStyle", {
+export declare const ValueMap: DB.TypeAlias<"ValueMap", DB.Object<{
+    options: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"Option", DB.Type>>>, true>;
+    style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
         Compressed: DB.EnumCase<null>;
         Verbose: DB.EnumCase<null>;
     }, []>>, true>;
-    translations: DB.MemberDecl<DB.NestedEntityMap<"ParameterMapTranslation", {
+    translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
         listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
             full: DB.MemberDecl<DB.String, true>;
             compressed: DB.MemberDecl<DB.String, false>;
@@ -31,4 +19,39 @@ export declare const ParameterMap: DB.TypeAlias<"ParameterMap", DB.Object<{
             compressed: DB.MemberDecl<DB.String, false>;
         }>, []>>, false>;
     }>, false>;
-}>, [Value: DB.Param<"Value", DB.Type>]>;
+}>, [Option: DB.Param<"Option", DB.Type>]>;
+export declare const ParameterMap: DB.TypeAlias<"ParameterMap", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ValueMap", DB.Object<{
+    options: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"Option", DB.Type>>>, true>;
+    style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
+        Compressed: DB.EnumCase<null>;
+        Verbose: DB.EnumCase<null>;
+    }, []>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
+        listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+            full: DB.MemberDecl<DB.String, true>;
+            compressed: DB.MemberDecl<DB.String, false>;
+        }>, []>>, false>;
+        listSuffix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+            full: DB.MemberDecl<DB.String, true>;
+            compressed: DB.MemberDecl<DB.String, false>;
+        }>, []>>, false>;
+        replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+            full: DB.MemberDecl<DB.String, true>;
+            compressed: DB.MemberDecl<DB.String, false>;
+        }>, []>>, false>;
+    }>, false>;
+}>, [Option: DB.Param<"Option", DB.Type>]>>, [Value: DB.Param<"Value", DB.Type>]>;
+export declare const createValueMapOption: <N extends string, Params extends DB.TypeParameter[], V extends {
+    [key: string]: DB.MemberDecl;
+}>(name: N, parameters: Params, getOptionValues: (...params: Params) => V, includeStandaloneLabel?: boolean) => DB.TypeAlias<N, DB.Object<V & {
+    translations: DB.MemberDecl<DB.NestedEntityMap<`${N}Translation`, {
+        standaloneLabel?: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+            full: DB.MemberDecl<DB.String, true>;
+            compressed: DB.MemberDecl<DB.String, false>;
+        }>, []>>, false> | undefined;
+        label: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+            full: DB.MemberDecl<DB.String, true>;
+            compressed: DB.MemberDecl<DB.String, false>;
+        }>, []>>, true>;
+    }>, true>;
+}>, Params>;

package/lib/types/_ActivatableSkillParameterMap.js

@@ -1,24 +1,24 @@
 import * as DB from "tsondb/schema/dsl";
 import { ResponsiveTextOptional } from "./_ResponsiveText.js";
 import { NestedTranslationMap } from "./Locale.js";
-export const ParameterMap = DB.GenTypeAlias(import.meta.url, {
-    name: "ParameterMap",
-    parameters: [DB.Param("Value")],
+export const ValueMap = DB.GenTypeAlias(import.meta.url, {
+    name: "ValueMap",
+    parameters: [DB.Param("Option")],
     comment: `A content that is \`2/4/8/16 AE (activation) + 1/2/4/8 per 5 minutes for an item the size of a cup/chest/door/castle gate\` can be represented as a cost map.
 
 The \`an item the size of a\` would be the *list prefix* string, while the list of options would contain four options with the activation cost and the name.`,
-    type: Value => DB.Object({
+    type: Option => DB.Object({
         options: DB.Required({
             comment: "The possible values and associated labels.",
-            type: DB.Array(DB.GenIncludeIdentifier(ParameterMapOption, [DB.TypeArgument(Value)]), {
+            type: DB.Array(DB.TypeArgument(Option), {
                 minItems: 2,
             }),
         }),
         style: DB.Required({
             comment: "The style of the generated string. It may either be displayed in a compressed way (e.g. `1/2/3 AE for a small/medium/large object`) or in a verbose way (e.g. `1 AE for a small object, 2 AE for a medium object, 3 AE for a large object`).",
-            type: DB.IncludeIdentifier(ParameterMapStyle),
+            type: DB.IncludeIdentifier(ValueMapStyle),
         }),
-        translations: NestedTranslationMap(DB.Optional, "ParameterMap", DB.Object({
+        translations: NestedTranslationMap(DB.Optional, "ValueMap", DB.Object({
             listPrefix: DB.Optional({
                 comment: "Place a string between the `for` and the grouped map option labels.",
                 type: DB.IncludeIdentifier(ResponsiveTextOptional),
@@ -28,37 +28,54 @@ The \`an item the size of a\` would be the *list prefix* string, while the list
                 type: DB.IncludeIdentifier(ResponsiveTextOptional),
             }),
             replacement: DB.Optional({
-                comment: "If the string from the book cannot be generated using the default generation technique, use this string. All options still need to be inserted propertly, since it may be used by in-game tools to provide a selection to players.",
+                comment: "If the string from the book cannot be generated using the default generation technique, use this string. All options still need to be inserted properly, since it may be used by in-game tools to provide a selection to players.",
                 type: DB.IncludeIdentifier(ResponsiveTextOptional),
             }),
         }, { minProperties: 1 })),
     }),
 });
-const ParameterMapStyle = DB.Enum(import.meta.url, {
-    name: "ParameterMapStyle",
+export const ParameterMap = DB.GenTypeAlias(import.meta.url, {
+    name: "ParameterMap",
+    parameters: [DB.Param("Value")],
+    comment: `A content that is \`2/4/8/16 AE (activation) + 1/2/4/8 per 5 minutes for an item the size of a cup/chest/door/castle gate\` can be represented as a cost map.
+
+The \`an item the size of a\` would be the *list prefix* string, while the list of options would contain four options with the activation cost and the name.`,
+    type: Value => DB.GenIncludeIdentifier(ValueMap, [
+        DB.GenIncludeIdentifier(ParameterMapOption, [DB.TypeArgument(Value)]),
+    ]),
+});
+const ValueMapStyle = DB.Enum(import.meta.url, {
+    name: "ValueMapStyle",
     comment: "The style of the generated string. It may either be displayed in a compressed way (e.g. `1/2/3 AE for a small/medium/large object`) or in a verbose way (e.g. `1 AE for a small object, 2 AE for a medium object, 3 AE for a large object`).",
     values: () => ({
         Compressed: DB.EnumCase({ type: null }),
         Verbose: DB.EnumCase({ type: null }),
     }),
 });
-const ParameterMapOption = DB.GenTypeAlias(import.meta.url, {
-    name: "ParameterMapOption",
-    parameters: [DB.Param("Value")],
-    type: Value => DB.Object({
-        value: DB.Required({
-            comment: "The value this option represents. If used for sustained cost, the interval cost is always half of this value.",
-            type: DB.TypeArgument(Value),
-        }),
-        translations: NestedTranslationMap(DB.Optional, "ParameterMapOption", DB.Object({
+export const createValueMapOption = (name, parameters, getOptionValues, includeStandaloneLabel = true) => DB.GenTypeAlias(import.meta.url, {
+    name,
+    parameters,
+    type: (...params) => DB.Object({
+        ...getOptionValues(...params),
+        translations: NestedTranslationMap(DB.Required, name, DB.Object({
             label: DB.Required({
                 comment: "The description of the option for cost string generation.",
                 type: DB.IncludeIdentifier(ResponsiveTextOptional),
             }),
-            standaloneLabel: DB.Optional({
-                comment: "The description of the option if used standalone (e.g. in an in-game tool where you can select how many AE you have to pay). Only used if different from `label`.",
-                type: DB.IncludeIdentifier(ResponsiveTextOptional),
-            }),
+            ...(includeStandaloneLabel
+                ? {
+                    standaloneLabel: DB.Optional({
+                        comment: "The description of the option if used standalone (e.g. in an in-game tool where you can select how many AE you have to pay). Only used if different from `label`.",
+                        type: DB.IncludeIdentifier(ResponsiveTextOptional),
+                    }),
+                }
+                : undefined),
         })),
     }),
 });
+const ParameterMapOption = createValueMapOption("ParameterMapOption", [DB.Param("Value")], Value => ({
+    value: DB.Required({
+        comment: "The value this option represents. If used for sustained cost, the interval cost is always half of this value.",
+        type: DB.TypeArgument(Value),
+    }),
+}));

package/lib/types/_Prerequisite.d.ts

@@ -149,6 +149,10 @@ export declare const ProfessionPrerequisites: DB.TypeAlias<"ProfessionPrerequisi
         }>, true>;
     }>, [T: DB.Param<"T", DB.Type>]>>>;
 }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>;
+export declare const ProfessionVariantPrerequisites: DB.TypeAlias<"ProfessionVariantPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainDiffPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisiteDiff", {
+    Add: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+    Remove: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+}, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>;
 export declare const AdvantageDisadvantagePrerequisites: DB.TypeAlias<"AdvantageDisadvantagePrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesForLevels", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteForLevel", DB.Object<{
     level: DB.MemberDecl<DB.Integer, true>;
     prerequisite: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {

package/lib/types/_Prerequisite.js

@@ -50,6 +50,27 @@ const PlainPrerequisites = DB.GenTypeAlias(import.meta.url, {
     parameters: [DB.Param("T")],
     type: T => DB.Array(DB.GenIncludeIdentifier(PrerequisitesElement, [DB.TypeArgument(T)]), { minItems: 1 }),
 });
+const PrerequisiteDiff = DB.GenEnum(import.meta.url, {
+    name: "PrerequisiteDiff",
+    parameters: [DB.Param("T")],
+    values: T => ({
+        Add: DB.EnumCase({
+            comment: "This prerequisite is added to the list of existing prerequisites.",
+            type: DB.TypeArgument(T),
+        }),
+        Remove: DB.EnumCase({
+            comment: "This prerequisite is removed from the list of existing prerequisites.",
+            type: DB.TypeArgument(T),
+        }),
+    }),
+});
+const PlainDiffPrerequisites = DB.GenTypeAlias(import.meta.url, {
+    name: "PlainDiffPrerequisites",
+    parameters: [DB.Param("T")],
+    type: T => DB.Array(DB.GenIncludeIdentifier(PrerequisiteDiff, [
+        DB.GenIncludeIdentifier(PrerequisitesElement, [DB.TypeArgument(T)]),
+    ]), { minItems: 1 }),
+});
 const PrerequisiteForLevel = DB.GenTypeAlias(import.meta.url, {
     name: "PrerequisiteForLevel",
     parameters: [DB.Param("T")],
@@ -103,6 +124,12 @@ export const ProfessionPrerequisites = DB.TypeAlias(import.meta.url, {
         DB.IncludeIdentifier(ProfessionPrerequisiteGroup),
     ]),
 });
+export const ProfessionVariantPrerequisites = DB.TypeAlias(import.meta.url, {
+    name: "ProfessionVariantPrerequisites",
+    type: () => DB.GenIncludeIdentifier(PlainDiffPrerequisites, [
+        DB.IncludeIdentifier(ProfessionPrerequisiteGroup),
+    ]),
+});
 export const AdvantageDisadvantagePrerequisites = DB.TypeAlias(import.meta.url, {
     name: "AdvantageDisadvantagePrerequisites",
     type: () => DB.GenIncludeIdentifier(PrerequisitesForLevels, [

package/lib/types/magicalActions/Bannzeichen.d.ts

@@ -51,25 +51,13 @@ export declare const Bannzeichen: DB.Entity<"Bannzeichen", {
                     }>, false>;
                 }>, []>>>, true>;
             }>, []>>>;
-            Map: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandaloneCostMap", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ParameterMap", DB.Object<{
-                options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ParameterMapOption", DB.Object<{
-                    value: DB.MemberDecl<DB.TypeArgument<DB.Param<"Value", DB.Type>>, true>;
-                    translations: DB.MemberDecl<DB.NestedEntityMap<"ParameterMapOptionTranslation", {
-                        label: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
-                            full: DB.MemberDecl<DB.String, true>;
-                            compressed: DB.MemberDecl<DB.String, false>;
-                        }>, []>>, true>;
-                        standaloneLabel: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
-                            full: DB.MemberDecl<DB.String, true>;
-                            compressed: DB.MemberDecl<DB.String, false>;
-                        }>, []>>, false>;
-                    }>, false>;
-                }>, [Value: DB.Param<"Value", DB.Type>]>>>, true>;
-                style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ParameterMapStyle", {
+            Map: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandaloneCostMap", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ParameterMap", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ValueMap", DB.Object<{
+                options: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"Option", DB.Type>>>, true>;
+                style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
                     Compressed: DB.EnumCase<null>;
                     Verbose: DB.EnumCase<null>;
                 }, []>>, true>;
-                translations: DB.MemberDecl<DB.NestedEntityMap<"ParameterMapTranslation", {
+                translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
                     listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
                         full: DB.MemberDecl<DB.String, true>;
                         compressed: DB.MemberDecl<DB.String, false>;
@@ -83,7 +71,7 @@ export declare const Bannzeichen: DB.Entity<"Bannzeichen", {
                         compressed: DB.MemberDecl<DB.String, false>;
                     }>, []>>, false>;
                 }>, false>;
-            }>, [Value: DB.Param<"Value", DB.Type>]>>, []>>>;
+            }>, [Option: DB.Param<"Option", DB.Type>]>>, [Value: DB.Param<"Value", DB.Type>]>>, []>>>;
             DerivedFromOption: DB.EnumCase<null>;
         }, []>>, true>;
         crafting_time: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"BannzeichenCraftingTime", DB.Object<{

package/lib/types/magicalActions/GeodeRitual.d.ts

@@ -19,25 +19,13 @@ export declare const GeodeRitual: DB.Entity<"GeodeRitual", {
             Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedGeodeRitualCost", DB.Object<{
                 value: DB.MemberDecl<DB.Integer, true>;
             }>, []>>>;
-            Map: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandaloneCostMap", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ParameterMap", DB.Object<{
-                options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ParameterMapOption", DB.Object<{
-                    value: DB.MemberDecl<DB.TypeArgument<DB.Param<"Value", DB.Type>>, true>;
-                    translations: DB.MemberDecl<DB.NestedEntityMap<"ParameterMapOptionTranslation", {
-                        label: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
-                            full: DB.MemberDecl<DB.String, true>;
-                            compressed: DB.MemberDecl<DB.String, false>;
-                        }>, []>>, true>;
-                        standaloneLabel: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
-                            full: DB.MemberDecl<DB.String, true>;
-                            compressed: DB.MemberDecl<DB.String, false>;
-                        }>, []>>, false>;
-                    }>, false>;
-                }>, [Value: DB.Param<"Value", DB.Type>]>>>, true>;
-                style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ParameterMapStyle", {
+            Map: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandaloneCostMap", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ParameterMap", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ValueMap", DB.Object<{
+                options: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"Option", DB.Type>>>, true>;
+                style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
                     Compressed: DB.EnumCase<null>;
                     Verbose: DB.EnumCase<null>;
                 }, []>>, true>;
-                translations: DB.MemberDecl<DB.NestedEntityMap<"ParameterMapTranslation", {
+                translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
                     listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
                         full: DB.MemberDecl<DB.String, true>;
                         compressed: DB.MemberDecl<DB.String, false>;
@@ -51,7 +39,7 @@ export declare const GeodeRitual: DB.Entity<"GeodeRitual", {
                         compressed: DB.MemberDecl<DB.String, false>;
                     }>, []>>, false>;
                 }>, false>;
-            }>, [Value: DB.Param<"Value", DB.Type>]>>, []>>>;
+            }>, [Option: DB.Param<"Option", DB.Type>]>>, [Value: DB.Param<"Value", DB.Type>]>>, []>>>;
         }, []>>, true>;
         range: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"GeodeRitualRange", {
             Self: DB.EnumCase<null>;

package/lib/types/magicalActions/ZibiljaRitual.d.ts

@@ -135,25 +135,13 @@ export declare const ZibiljaRitual: DB.Entity<"ZibiljaRitual", {
             }, []>>>, []>>>;
             Map: DB.EnumCase<DB.IncludeIdentifier<[], DB.Enum<"OneTimeCostMap", {
                 Modifiable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ModifiableOneTimeCostMap", DB.Object<{
-                    map: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ParameterMap", DB.Object<{
-                        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ParameterMapOption", DB.Object<{
-                            value: DB.MemberDecl<DB.TypeArgument<DB.Param<"Value", DB.Type>>, true>;
-                            translations: DB.MemberDecl<DB.NestedEntityMap<"ParameterMapOptionTranslation", {
-                                label: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
-                                    full: DB.MemberDecl<DB.String, true>;
-                                    compressed: DB.MemberDecl<DB.String, false>;
-                                }>, []>>, true>;
-                                standaloneLabel: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
-                                    full: DB.MemberDecl<DB.String, true>;
-                                    compressed: DB.MemberDecl<DB.String, false>;
-                                }>, []>>, false>;
-                            }>, false>;
-                        }>, [Value: DB.Param<"Value", DB.Type>]>>>, true>;
-                        style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ParameterMapStyle", {
+                    map: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ParameterMap", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ValueMap", DB.Object<{
+                        options: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"Option", DB.Type>>>, true>;
+                        style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
                             Compressed: DB.EnumCase<null>;
                             Verbose: DB.EnumCase<null>;
                         }, []>>, true>;
-                        translations: DB.MemberDecl<DB.NestedEntityMap<"ParameterMapTranslation", {
+                        translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
                             listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
                                 full: DB.MemberDecl<DB.String, true>;
                                 compressed: DB.MemberDecl<DB.String, false>;
@@ -167,28 +155,16 @@ export declare const ZibiljaRitual: DB.Entity<"ZibiljaRitual", {
                                 compressed: DB.MemberDecl<DB.String, false>;
                             }>, []>>, false>;
                         }>, false>;
-                    }>, [Value: DB.Param<"Value", DB.Type>]>>, true>;
+                    }>, [Option: DB.Param<"Option", DB.Type>]>>, [Value: DB.Param<"Value", DB.Type>]>>, true>;
                 }>, []>>>;
                 NonModifiable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"NonModifiableOneTimeCostMap", DB.Object<{
-                    map: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ParameterMap", DB.Object<{
-                        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ParameterMapOption", DB.Object<{
-                            value: DB.MemberDecl<DB.TypeArgument<DB.Param<"Value", DB.Type>>, true>;
-                            translations: DB.MemberDecl<DB.NestedEntityMap<"ParameterMapOptionTranslation", {
-                                label: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
-                                    full: DB.MemberDecl<DB.String, true>;
-                                    compressed: DB.MemberDecl<DB.String, false>;
-                                }>, []>>, true>;
-                                standaloneLabel: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
-                                    full: DB.MemberDecl<DB.String, true>;
-                                    compressed: DB.MemberDecl<DB.String, false>;
-                                }>, []>>, false>;
-                            }>, false>;
-                        }>, [Value: DB.Param<"Value", DB.Type>]>>>, true>;
-                        style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ParameterMapStyle", {
+                    map: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ParameterMap", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ValueMap", DB.Object<{
+                        options: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"Option", DB.Type>>>, true>;
+                        style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
                             Compressed: DB.EnumCase<null>;
                             Verbose: DB.EnumCase<null>;
                         }, []>>, true>;
-                        translations: DB.MemberDecl<DB.NestedEntityMap<"ParameterMapTranslation", {
+                        translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
                             listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
                                 full: DB.MemberDecl<DB.String, true>;
                                 compressed: DB.MemberDecl<DB.String, false>;
@@ -202,7 +178,7 @@ export declare const ZibiljaRitual: DB.Entity<"ZibiljaRitual", {
                                 compressed: DB.MemberDecl<DB.String, false>;
                             }>, []>>, false>;
                         }>, false>;
-                    }>, [Value: DB.Param<"Value", DB.Type>]>>, true>;
+                    }>, [Option: DB.Param<"Option", DB.Type>]>>, [Value: DB.Param<"Value", DB.Type>]>>, true>;
                 }>, []>>>;
             }, []>>>;
         }, []>>, true>;

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

@@ -1211,7 +1211,30 @@ export declare const AdvancedCombatSpecialAbility: DB.Entity<"AdvancedCombatSpec
                 threshold: DB.MemberDecl<DB.Integer, true>;
                 alternative: DB.MemberDecl<DB.Integer, true>;
             }>, []>>>;
-            Expression: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], import("../_MathExpression.ts").MathOperation>, []>>>;
+            Expression: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpression", DB.Object<{
+                expression: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpressionExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], import("../_MathExpression.ts").MathOperation>, []>>, true>;
+                customLabels: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpressionLabels", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ValueMap", DB.Object<{
+                    options: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"Option", DB.Type>>>, true>;
+                    style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
+                        Compressed: DB.EnumCase<null>;
+                        Verbose: DB.EnumCase<null>;
+                    }, []>>, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
+                        listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, false>;
+                        listSuffix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, false>;
+                        replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, false>;
+                    }>, false>;
+                }>, [Option: DB.Param<"Option", DB.Type>]>>, []>>, false>;
+            }>, []>>>;
         }, []>>>;
         Indefinite: DB.EnumCase<null>;
     }, []>>, true>;

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

@@ -1087,7 +1087,30 @@ export declare const AdvancedKarmaSpecialAbility: DB.Entity<"AdvancedKarmaSpecia
                 threshold: DB.MemberDecl<DB.Integer, true>;
                 alternative: DB.MemberDecl<DB.Integer, true>;
             }>, []>>>;
-            Expression: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], import("../_MathExpression.ts").MathOperation>, []>>>;
+            Expression: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpression", DB.Object<{
+                expression: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpressionExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], import("../_MathExpression.ts").MathOperation>, []>>, true>;
+                customLabels: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpressionLabels", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ValueMap", DB.Object<{
+                    options: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"Option", DB.Type>>>, true>;
+                    style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
+                        Compressed: DB.EnumCase<null>;
+                        Verbose: DB.EnumCase<null>;
+                    }, []>>, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
+                        listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, false>;
+                        listSuffix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, false>;
+                        replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, false>;
+                    }>, false>;
+                }>, [Option: DB.Param<"Option", DB.Type>]>>, []>>, false>;
+            }>, []>>>;
         }, []>>>;
         Indefinite: DB.EnumCase<null>;
     }, []>>, true>;

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

@@ -1087,7 +1087,30 @@ export declare const AdvancedMagicalSpecialAbility: DB.Entity<"AdvancedMagicalSp
                 threshold: DB.MemberDecl<DB.Integer, true>;
                 alternative: DB.MemberDecl<DB.Integer, true>;
             }>, []>>>;
-            Expression: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], import("../_MathExpression.ts").MathOperation>, []>>>;
+            Expression: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpression", DB.Object<{
+                expression: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpressionExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], import("../_MathExpression.ts").MathOperation>, []>>, true>;
+                customLabels: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpressionLabels", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ValueMap", DB.Object<{
+                    options: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"Option", DB.Type>>>, true>;
+                    style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
+                        Compressed: DB.EnumCase<null>;
+                        Verbose: DB.EnumCase<null>;
+                    }, []>>, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
+                        listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, false>;
+                        listSuffix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, false>;
+                        replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, false>;
+                    }>, false>;
+                }>, [Option: DB.Param<"Option", DB.Type>]>>, []>>, false>;
+            }>, []>>>;
         }, []>>>;
         Indefinite: DB.EnumCase<null>;
     }, []>>, true>;

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

@@ -1087,7 +1087,30 @@ export declare const AdvancedSkillSpecialAbility: DB.Entity<"AdvancedSkillSpecia
                 threshold: DB.MemberDecl<DB.Integer, true>;
                 alternative: DB.MemberDecl<DB.Integer, true>;
             }>, []>>>;
-            Expression: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], import("../_MathExpression.ts").MathOperation>, []>>>;
+            Expression: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpression", DB.Object<{
+                expression: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpressionExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], import("../_MathExpression.ts").MathOperation>, []>>, true>;
+                customLabels: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpressionLabels", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ValueMap", DB.Object<{
+                    options: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"Option", DB.Type>>>, true>;
+                    style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
+                        Compressed: DB.EnumCase<null>;
+                        Verbose: DB.EnumCase<null>;
+                    }, []>>, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
+                        listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, false>;
+                        listSuffix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, false>;
+                        replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, false>;
+                    }>, false>;
+                }>, [Option: DB.Param<"Option", DB.Type>]>>, []>>, false>;
+            }>, []>>>;
         }, []>>>;
         Indefinite: DB.EnumCase<null>;
     }, []>>, true>;

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

@@ -1034,7 +1034,30 @@ export declare const AncestorGlyph: DB.Entity<"AncestorGlyph", {
                 threshold: DB.MemberDecl<DB.Integer, true>;
                 alternative: DB.MemberDecl<DB.Integer, true>;
             }>, []>>>;
-            Expression: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], import("../_MathExpression.ts").MathOperation>, []>>>;
+            Expression: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpression", DB.Object<{
+                expression: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpressionExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], import("../_MathExpression.ts").MathOperation>, []>>, true>;
+                customLabels: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpressionLabels", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ValueMap", DB.Object<{
+                    options: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"Option", DB.Type>>>, true>;
+                    style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
+                        Compressed: DB.EnumCase<null>;
+                        Verbose: DB.EnumCase<null>;
+                    }, []>>, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
+                        listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, false>;
+                        listSuffix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, false>;
+                        replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, false>;
+                    }>, false>;
+                }>, [Option: DB.Param<"Option", DB.Type>]>>, []>>, false>;
+            }>, []>>>;
         }, []>>>;
         Indefinite: DB.EnumCase<null>;
     }, []>>, true>;

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

@@ -1109,7 +1109,30 @@ export declare const BlessedTradition: DB.Entity<"BlessedTradition", {
                 threshold: DB.MemberDecl<DB.Integer, true>;
                 alternative: DB.MemberDecl<DB.Integer, true>;
             }>, []>>>;
-            Expression: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], import("../_MathExpression.ts").MathOperation>, []>>>;
+            Expression: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpression", DB.Object<{
+                expression: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpressionExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], import("../_MathExpression.ts").MathOperation>, []>>, true>;
+                customLabels: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpressionLabels", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ValueMap", DB.Object<{
+                    options: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"Option", DB.Type>>>, true>;
+                    style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
+                        Compressed: DB.EnumCase<null>;
+                        Verbose: DB.EnumCase<null>;
+                    }, []>>, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
+                        listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, false>;
+                        listSuffix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, false>;
+                        replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
+                        }>, []>>, false>;
+                    }>, false>;
+                }>, [Option: DB.Param<"Option", DB.Type>]>>, []>>, false>;
+            }>, []>>>;
         }, []>>>;
         Indefinite: DB.EnumCase<null>;
     }, []>>, true>;