@optolith/database-schema 0.53.0 → 0.55.0

package/lib/types/prerequisites/single/PropertyPrerequisite.d.ts

@@ -0,0 +1,16 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const PropertyPrerequisite: DB.TypeAlias<"PropertyPrerequisite", DB.Object<{
+    id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+        Hide: DB.EnumCase<null>;
+        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                Standalone: DB.EnumCase<null>;
+                Connected: DB.EnumCase<null>;
+            }, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                replacement: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;

package/lib/types/prerequisites/single/PropertyPrerequisite.js

@@ -0,0 +1,16 @@
+import * as DB from "tsondb/schema/dsl";
+import { PropertyIdentifier } from "../../_Identifier.js";
+import { DisplayOption } from "../DisplayOption.js";
+export const PropertyPrerequisite = DB.TypeAlias(import.meta.url, {
+    name: "PropertyPrerequisite",
+    comment: "Requires a specific property or one of a specific set of properties.",
+    type: () => DB.Object({
+        id: DB.Required({
+            comment: "The property�s identifier.",
+            type: PropertyIdentifier(),
+        }),
+        display_option: DB.Optional({
+            type: DB.IncludeIdentifier(DisplayOption),
+        }),
+    }),
+});

package/lib/types/specialAbility/AdvancedCombatSpecialAbility.js

@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl";
 import { input, levels, maximum, name, name_in_library, rules } from "../_Activatable.js";
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js";
-import { combat_techniques, penalty, usage_type } from "../_ActivatableCombat.js";
+import { combat_techniques, penalty, special_ability_usage_type } from "../_ActivatableCombat.js";
 import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.js";
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js";
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js";
@@ -16,7 +16,7 @@ export const AdvancedCombatSpecialAbility = DB.Entity(import.meta.url, {
     type: () => DB.Object({
         levels,
         nameBuilderRules,
-        usage_type,
+        usage_type: special_ability_usage_type,
         select_options,
         explicit_select_options,
         skill_applications,

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

@@ -968,10 +968,6 @@ export declare const BlessedTradition: DB.Entity<"BlessedTradition", {
     primary: DB.MemberDecl<DB.ReferenceIdentifier, false>;
     aspects: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
     primaryBlessing: DB.MemberDecl<DB.ReferenceIdentifier, false>;
-    restricted_blessings: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RestrictedBlessings", {
-        Three: DB.EnumCase<DB.Array<DB.ReferenceIdentifier>>;
-        Six: DB.EnumCase<DB.Array<DB.ReferenceIdentifier>>;
-    }, []>>, false>;
     favored_combat_techniques: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"FavoredCombatTechniques", {
         All: DB.EnumCase<null>;
         AllClose: DB.EnumCase<null>;
@@ -989,7 +985,12 @@ export declare const BlessedTradition: DB.Entity<"BlessedTradition", {
         options: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
     }>, []>>, false>;
     type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"BlessedTraditionType", {
-        Church: DB.EnumCase<null>;
+        Church: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ChurchBlessedTradition", DB.Object<{
+            restrictedBlessings: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RestrictedBlessings", {
+                Three: DB.EnumCase<DB.Array<DB.ReferenceIdentifier>>;
+                Six: DB.EnumCase<DB.Array<DB.ReferenceIdentifier>>;
+            }, []>>, false>;
+        }>, []>>>;
         Shamanistic: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ShamanisticBlessedTradition", DB.Object<{
             can_use_bone_mace_as_ceremonial_item: DB.MemberDecl<DB.Boolean, true>;
         }>, []>>>;

package/lib/types/specialAbility/BlessedTradition.js

@@ -31,10 +31,6 @@ export const BlessedTradition = DB.Entity(import.meta.url, {
             comment: "The tradition’s primary blessing. Leave empty if the tradition does not have one.",
             type: BlessingIdentifier(),
         }),
-        restricted_blessings: DB.Optional({
-            comment: "If a tradition restricts the possible blessings, the blessings that are **not** allowed.",
-            type: DB.IncludeIdentifier(RestrictedBlessings),
-        }),
         favored_combat_techniques: DB.Optional({
             comment: "A list of favored combat techniques.",
             type: DB.IncludeIdentifier(FavoredCombatTechniques),
@@ -138,10 +134,20 @@ const BlessedTraditionType = DB.Enum(import.meta.url, {
     name: "BlessedTraditionType",
     comment: "The type of the tradition. May be either church or shamanistic.",
     values: () => ({
-        Church: DB.EnumCase({ type: null }),
+        Church: DB.EnumCase({ type: DB.IncludeIdentifier(ChurchBlessedTradition) }),
         Shamanistic: DB.EnumCase({ type: DB.IncludeIdentifier(ShamanisticBlessedTradition) }),
     }),
 });
+const ChurchBlessedTradition = DB.TypeAlias(import.meta.url, {
+    name: "ChurchBlessedTradition",
+    comment: "Additional rules for church traditions.",
+    type: () => DB.Object({
+        restrictedBlessings: DB.Optional({
+            comment: "If a tradition restricts the possible blessings, the blessings that are **not** allowed.",
+            type: DB.IncludeIdentifier(RestrictedBlessings),
+        }),
+    }),
+});
 const ShamanisticBlessedTradition = DB.TypeAlias(import.meta.url, {
     name: "ShamanisticBlessedTradition",
     comment: "Additional rules for shamanistic traditions.",

package/lib/types/specialAbility/BrawlingSpecialAbility.js

@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl";
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js";
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js";
-import { combat_techniques, usage_type } from "../_ActivatableCombat.js";
+import { combat_techniques, special_ability_usage_type } from "../_ActivatableCombat.js";
 import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.js";
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js";
 import { GeneralPrerequisites } from "../_Prerequisite.js";
@@ -14,7 +14,7 @@ export const BrawlingSpecialAbility = DB.Entity(import.meta.url, {
     type: () => DB.Object({
         levels,
         nameBuilderRules,
-        usage_type,
+        usage_type: special_ability_usage_type,
         select_options,
         explicit_select_options,
         maximum,

package/lib/types/specialAbility/CombatSpecialAbility.js

@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl";
 import { input, levels, maximum, name, name_in_library, rules } from "../_Activatable.js";
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js";
-import { combat_techniques, penalty, penalty_l10n, usage_type } from "../_ActivatableCombat.js";
+import { combat_techniques, penalty, penalty_l10n, special_ability_usage_type, } from "../_ActivatableCombat.js";
 import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.js";
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js";
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js";
@@ -15,7 +15,7 @@ export const CombatSpecialAbility = DB.Entity(import.meta.url, {
     type: () => DB.Object({
         levels,
         nameBuilderRules,
-        usage_type,
+        usage_type: special_ability_usage_type,
         select_options,
         explicit_select_options,
         skill_applications,

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

@@ -8,10 +8,9 @@ export declare const CombatStyleSpecialAbility: DB.Entity<"CombatStyleSpecialAbi
         }, []>>, false>;
         useParenthesis: DB.MemberDecl<DB.Boolean, false>;
     }>, []>>, false>;
-    usage_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CombatSpecialAbilityUsageType", {
+    usage_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CombatSpecialAbilityTypeUsageType", {
         Passive: DB.EnumCase<null>;
-        BasicManeuver: DB.EnumCase<null>;
-        SpecialManeuver: DB.EnumCase<null>;
+        Active: DB.EnumCase<null>;
     }, []>>, true>;
     type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CombatSpecialAbilityType", {
         Armed: DB.EnumCase<null>;

package/lib/types/specialAbility/CombatStyleSpecialAbility.js

@@ -2,7 +2,7 @@ import * as DB from "tsondb/schema/dsl";
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js";
 import { advanced } from "../_ActivatableAdvanced.js";
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js";
-import { combat_techniques, penalty, type, usage_type } from "../_ActivatableCombat.js";
+import { combat_techniques, penalty, type, style_usage_type } from "../_ActivatableCombat.js";
 import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.js";
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js";
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js";
@@ -17,7 +17,7 @@ export const CombatStyleSpecialAbility = DB.Entity(import.meta.url, {
     type: () => DB.Object({
         levels,
         nameBuilderRules,
-        usage_type,
+        usage_type: style_usage_type,
         type,
         select_options,
         explicit_select_options,

package/lib/types/specialAbility/CommandSpecialAbility.js

@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl";
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js";
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js";
-import { combat_techniques, usage_type } from "../_ActivatableCombat.js";
+import { combat_techniques, special_ability_usage_type } from "../_ActivatableCombat.js";
 import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.js";
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js";
 import { GeneralPrerequisites } from "../_Prerequisite.js";
@@ -14,7 +14,7 @@ export const CommandSpecialAbility = DB.Entity(import.meta.url, {
     type: () => DB.Object({
         levels,
         nameBuilderRules,
-        usage_type,
+        usage_type: special_ability_usage_type,
         select_options,
         explicit_select_options,
         maximum,

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

@@ -1183,6 +1183,7 @@ export declare const MagicStyleSpecialAbility: DB.Entity<"MagicStyleSpecialAbili
     }>, []>>>, []>>, true>;
     translations: DB.MemberDecl<DB.NestedEntityMap<"MagicStyleSpecialAbilityTranslation", {
         name: DB.MemberDecl<DB.String, true>;
+        additionalName: DB.MemberDecl<DB.String, false>;
         name_in_library: DB.MemberDecl<DB.String, false>;
         rules: DB.MemberDecl<DB.String, true>;
         ap_value_append: DB.MemberDecl<DB.String, false>;

package/lib/types/specialAbility/MagicStyleSpecialAbility.js

@@ -1,5 +1,5 @@
 import * as DB from "tsondb/schema/dsl";
-import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js";
+import { additionalName, levels, maximum, name, name_in_library, rules } from "../_Activatable.js";
 import { advanced } from "../_ActivatableAdvanced.js";
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js";
 import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.js";
@@ -29,6 +29,7 @@ export const MagicStyleSpecialAbility = DB.Entity(import.meta.url, {
         src,
         translations: NestedTranslationMap(DB.Required, "MagicStyleSpecialAbility", DB.Object({
             name,
+            additionalName,
             name_in_library,
             rules,
             ap_value_append,

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

@@ -32,31 +32,30 @@ export declare const MagicalSign: DB.Entity<"MagicalSign", {
             value: DB.MemberDecl<DB.Integer, true>;
             permanent_value: DB.MemberDecl<DB.Integer, false>;
         }>, []>>>;
-        Map: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"OneTimeCostMap", DB.Object<{
-            options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"OneTimeCostMapOption", DB.Object<{
-                value: DB.MemberDecl<DB.Integer, true>;
-                permanent_value: DB.MemberDecl<DB.Integer, false>;
-                translations: DB.MemberDecl<DB.NestedEntityMap<"OneTimeCostMapOptionTranslation", {
+        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>;
-                    label_standalone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                    standaloneLabel: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
                         full: DB.MemberDecl<DB.String, true>;
                         compressed: DB.MemberDecl<DB.String, false>;
                     }>, []>>, false>;
                 }>, false>;
-            }>, []>>>, true>;
-            style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"MapStyle", {
+            }>, [Value: DB.Param<"Value", DB.Type>]>>>, true>;
+            style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ParameterMapStyle", {
                 Compressed: DB.EnumCase<null>;
                 Verbose: DB.EnumCase<null>;
-            }, []>>, false>;
-            translations: DB.MemberDecl<DB.NestedEntityMap<"OneTimeCostMapTranslation", {
-                list_prepend: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+            }, []>>, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ParameterMapTranslation", {
+                listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
                     full: DB.MemberDecl<DB.String, true>;
                     compressed: DB.MemberDecl<DB.String, false>;
                 }>, []>>, false>;
-                list_append: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                listSuffix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
                     full: DB.MemberDecl<DB.String, true>;
                     compressed: DB.MemberDecl<DB.String, false>;
                 }>, []>>, false>;
@@ -65,7 +64,7 @@ export declare const MagicalSign: DB.Entity<"MagicalSign", {
                     compressed: DB.MemberDecl<DB.String, false>;
                 }>, []>>, false>;
             }>, false>;
-        }>, []>>>;
+        }>, [Value: DB.Param<"Value", DB.Type>]>>, []>>>;
     }, []>>, false>;
     property: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"PropertyDeclaration", {
         DependingOnSelection: DB.EnumCase<null>;

package/lib/types/specialAbility/MagicalSign.js

@@ -3,7 +3,7 @@ import { effect, name, name_in_library } from "../_Activatable.js";
 import { ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js";
 import { activatableDisplayNameCustomizer } from "../_ActivatableNames.js";
 import { propertyOptional } from "../_ActivatableNonMundane.js";
-import { OneTimeCostMap } from "../_ActivatableSkillCost.js";
+import { StandaloneCostMap } from "../_ActivatableSkillCost.js";
 import { GeneralPrerequisites } from "../_Prerequisite.js";
 import { NestedTranslationMap } from "../Locale.js";
 import { Errata } from "../source/_Erratum.js";
@@ -50,7 +50,7 @@ const MagicalSignCost = DB.Enum(import.meta.url, {
     name: "MagicalSignCost",
     values: () => ({
         Constant: DB.EnumCase({ type: DB.IncludeIdentifier(ConstantMagicalSignCost) }),
-        Map: DB.EnumCase({ type: DB.IncludeIdentifier(OneTimeCostMap) }),
+        Map: DB.EnumCase({ type: DB.IncludeIdentifier(StandaloneCostMap) }),
     }),
 });
 const ConstantMagicalSignCost = DB.TypeAlias(import.meta.url, {

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

@@ -959,32 +959,30 @@ export declare const ArcaneOrbEnchantment: DB.Entity<"ArcaneOrbEnchantment", {
                 points: DB.MemberDecl<DB.Integer, true>;
             }>, []>>>, true>;
         }>, []>>>;
-        Map: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VolumeMap", DB.Object<{
-            options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"VolumeMapOption", DB.Object<{
-                points: DB.MemberDecl<DB.Integer, true>;
-                associated_options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"VolumeMapOptionAssociatedOption", DB.Object<{
-                    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"VolumePointsOptionReferenceIdentifier", {
-                        General: DB.EnumCase<DB.ReferenceIdentifier>;
-                        AnimalShapeSize: DB.EnumCase<DB.ReferenceIdentifier>;
-                    }, []>>, true>;
-                }>, []>>>, true>;
-                translations: DB.MemberDecl<DB.NestedEntityMap<"VolumeMapOptionTranslation", {
+        Map: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VolumeMap", 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>;
-                    label_standalone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                    standaloneLabel: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
                         full: DB.MemberDecl<DB.String, true>;
                         compressed: DB.MemberDecl<DB.String, false>;
                     }>, []>>, false>;
                 }>, false>;
-            }>, []>>>, true>;
-            translations: DB.MemberDecl<DB.NestedEntityMap<"VolumeMapTranslation", {
-                list_prepend: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+            }>, [Value: DB.Param<"Value", DB.Type>]>>>, true>;
+            style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ParameterMapStyle", {
+                Compressed: DB.EnumCase<null>;
+                Verbose: DB.EnumCase<null>;
+            }, []>>, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ParameterMapTranslation", {
+                listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
                     full: DB.MemberDecl<DB.String, true>;
                     compressed: DB.MemberDecl<DB.String, false>;
                 }>, []>>, false>;
-                list_append: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                listSuffix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
                     full: DB.MemberDecl<DB.String, true>;
                     compressed: DB.MemberDecl<DB.String, false>;
                 }>, []>>, false>;
@@ -993,7 +991,7 @@ export declare const ArcaneOrbEnchantment: DB.Entity<"ArcaneOrbEnchantment", {
                     compressed: DB.MemberDecl<DB.String, false>;
                 }>, []>>, false>;
             }>, false>;
-        }>, []>>>;
+        }>, [Value: DB.Param<"Value", DB.Type>]>>, []>>>;
         DerivedFromSelection: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VolumeDerivedFromSelection", DB.Object<{
             fallback: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>;
@@ -1017,6 +1015,16 @@ export declare const ArcaneOrbEnchantment: DB.Entity<"ArcaneOrbEnchantment", {
                         Centuries: DB.EnumCase<null>;
                         Actions: DB.EnumCase<null>;
                         CombatRounds: DB.EnumCase<null>;
+                        Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomDurationUnit", DB.Object<{
+                            translations: DB.MemberDecl<DB.NestedEntityMap<"CustomDurationUnitTranslation", {
+                                name: DB.MemberDecl<DB.String, true>;
+                                fullNumber: DB.MemberDecl<DB.String, true>;
+                                full: DB.MemberDecl<DB.String, true>;
+                                symbol: DB.MemberDecl<DB.String, true>;
+                                compressedNumber: DB.MemberDecl<DB.String, true>;
+                                compressed: DB.MemberDecl<DB.String, true>;
+                            }>, true>;
+                        }>, []>>>;
                     }, []>>, true>;
                 }>, []>>, false>;
                 per_level: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"FixedArcaneEnergyCostPerLevel", {
@@ -1060,6 +1068,16 @@ export declare const ArcaneOrbEnchantment: DB.Entity<"ArcaneOrbEnchantment", {
                         Centuries: DB.EnumCase<null>;
                         Actions: DB.EnumCase<null>;
                         CombatRounds: DB.EnumCase<null>;
+                        Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomDurationUnit", DB.Object<{
+                            translations: DB.MemberDecl<DB.NestedEntityMap<"CustomDurationUnitTranslation", {
+                                name: DB.MemberDecl<DB.String, true>;
+                                fullNumber: DB.MemberDecl<DB.String, true>;
+                                full: DB.MemberDecl<DB.String, true>;
+                                symbol: DB.MemberDecl<DB.String, true>;
+                                compressedNumber: DB.MemberDecl<DB.String, true>;
+                                compressed: DB.MemberDecl<DB.String, true>;
+                            }>, true>;
+                        }>, []>>>;
                     }, []>>, true>;
                 }>, []>>, true>;
             }>, []>>>;
@@ -1079,6 +1097,16 @@ export declare const ArcaneOrbEnchantment: DB.Entity<"ArcaneOrbEnchantment", {
                         Centuries: DB.EnumCase<null>;
                         Actions: DB.EnumCase<null>;
                         CombatRounds: DB.EnumCase<null>;
+                        Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomDurationUnit", DB.Object<{
+                            translations: DB.MemberDecl<DB.NestedEntityMap<"CustomDurationUnitTranslation", {
+                                name: DB.MemberDecl<DB.String, true>;
+                                fullNumber: DB.MemberDecl<DB.String, true>;
+                                full: DB.MemberDecl<DB.String, true>;
+                                symbol: DB.MemberDecl<DB.String, true>;
+                                compressedNumber: DB.MemberDecl<DB.String, true>;
+                                compressed: DB.MemberDecl<DB.String, true>;
+                            }>, true>;
+                        }>, []>>>;
                     }, []>>, true>;
                 }>, []>>, true>;
             }>, []>>>;
@@ -1117,31 +1145,30 @@ export declare const ArcaneOrbEnchantment: DB.Entity<"ArcaneOrbEnchantment", {
                     Verbose: DB.EnumCase<null>;
                 }, []>>, true>;
             }>, []>>>;
-            Map: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"OneTimeCostMap", DB.Object<{
-                options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"OneTimeCostMapOption", DB.Object<{
-                    value: DB.MemberDecl<DB.Integer, true>;
-                    permanent_value: DB.MemberDecl<DB.Integer, false>;
-                    translations: DB.MemberDecl<DB.NestedEntityMap<"OneTimeCostMapOptionTranslation", {
+            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>;
-                        label_standalone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                        standaloneLabel: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
                             full: DB.MemberDecl<DB.String, true>;
                             compressed: DB.MemberDecl<DB.String, false>;
                         }>, []>>, false>;
                     }>, false>;
-                }>, []>>>, true>;
-                style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"MapStyle", {
+                }>, [Value: DB.Param<"Value", DB.Type>]>>>, true>;
+                style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ParameterMapStyle", {
                     Compressed: DB.EnumCase<null>;
                     Verbose: DB.EnumCase<null>;
-                }, []>>, false>;
-                translations: DB.MemberDecl<DB.NestedEntityMap<"OneTimeCostMapTranslation", {
-                    list_prepend: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                }, []>>, true>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"ParameterMapTranslation", {
+                    listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
                         full: DB.MemberDecl<DB.String, true>;
                         compressed: DB.MemberDecl<DB.String, false>;
                     }>, []>>, false>;
-                    list_append: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                    listSuffix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
                         full: DB.MemberDecl<DB.String, true>;
                         compressed: DB.MemberDecl<DB.String, false>;
                     }>, []>>, false>;
@@ -1150,7 +1177,7 @@ export declare const ArcaneOrbEnchantment: DB.Entity<"ArcaneOrbEnchantment", {
                         compressed: DB.MemberDecl<DB.String, false>;
                     }>, []>>, false>;
                 }>, false>;
-            }>, []>>>;
+            }>, [Value: DB.Param<"Value", DB.Type>]>>, []>>>;
         }, []>>>;
         BindingCost: DB.EnumCase<DB.IncludeIdentifier<[], DB.Enum<"BindingCost", {
             Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedBindingCost", DB.Object<{
@@ -1159,26 +1186,30 @@ export declare const ArcaneOrbEnchantment: DB.Entity<"ArcaneOrbEnchantment", {
             PerLevel: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"BindingCostPerLevel", DB.Object<{
                 permanent_value: DB.MemberDecl<DB.Integer, true>;
             }>, []>>>;
-            Map: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"BindingCostMap", DB.Object<{
-                options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"BindingCostMapOption", DB.Object<{
-                    permanent_value: DB.MemberDecl<DB.Integer, true>;
-                    translations: DB.MemberDecl<DB.NestedEntityMap<"BindingCostMapOptionTranslation", {
+            Map: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"BindingCostMap", 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>;
-                        label_standalone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                        standaloneLabel: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
                             full: DB.MemberDecl<DB.String, true>;
                             compressed: DB.MemberDecl<DB.String, false>;
                         }>, []>>, false>;
-                    }>, true>;
-                }>, []>>>, true>;
-                translations: DB.MemberDecl<DB.NestedEntityMap<"BindingCostMapTranslation", {
-                    list_prepend: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                    }>, false>;
+                }>, [Value: DB.Param<"Value", DB.Type>]>>>, true>;
+                style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ParameterMapStyle", {
+                    Compressed: DB.EnumCase<null>;
+                    Verbose: DB.EnumCase<null>;
+                }, []>>, true>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"ParameterMapTranslation", {
+                    listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
                         full: DB.MemberDecl<DB.String, true>;
                         compressed: DB.MemberDecl<DB.String, false>;
                     }>, []>>, false>;
-                    list_append: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                    listSuffix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
                         full: DB.MemberDecl<DB.String, true>;
                         compressed: DB.MemberDecl<DB.String, false>;
                     }>, []>>, false>;
@@ -1187,7 +1218,7 @@ export declare const ArcaneOrbEnchantment: DB.Entity<"ArcaneOrbEnchantment", {
                         compressed: DB.MemberDecl<DB.String, false>;
                     }>, []>>, false>;
                 }>, false>;
-            }>, []>>>;
+            }>, [Value: DB.Param<"Value", DB.Type>]>>, []>>>;
             DerivedFromSelection: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"BindingCostDerivedFromSelection", DB.Object<{
                 fallback: DB.MemberDecl<DB.Integer, true>;
                 translations: DB.MemberDecl<DB.NestedEntityMap<"BindingCostDerivedFromSelectionTranslation", {