@optolith/database-schema 0.52.2 → 0.54.0

package/lib/types/_ActivatableSkillCost.js

@@ -1,5 +1,6 @@
 import * as DB from "tsondb/schema/dsl";
 import { DurationUnitValue } from "./_ActivatableSkillDuration.js";
+import { ParameterMap } from "./_ActivatableSkillParameterMap.js";
 import { SkillModificationLevelIdentifier } from "./_Identifier.js";
 import { ResponsiveText, ResponsiveTextOptional, ResponsiveTextReplace } from "./_ResponsiveText.js";
 import { NestedTranslationMap } from "./Locale.js";
@@ -98,88 +99,32 @@ export const IndefiniteOneTimeCost = DB.TypeAlias(import.meta.url, {
         })),
     }),
 });
-export const OneTimeCostMap = DB.TypeAlias(import.meta.url, {
+const OneTimeCostMap = DB.Enum(import.meta.url, {
     name: "OneTimeCostMap",
-    comment: `A content that is \`2/4/8/16 AE for an item the size of a cup/chest/door/castle gate\` may be respresented as the following map:
-
-\`\`\`yaml
-options:
-  - value: 2
-    label: "cup"
-  - value: 4
-    label: "chest"
-  - value: 8
-    label: "door"
-  - value: 16
-    label: "castle gate"
-for_append: "an item the size of a"
-\`\`\`
-
-This will generate the exact same string as seen above – given it is set for a spellwork and thus \`AE\` is used.`,
-    type: () => DB.Object({
-        options: DB.Required({
-            comment: "The possible costs and associated labels.",
-            type: DB.Array(DB.IncludeIdentifier(OneTimeCostMapOption), {
-                minItems: 2,
-            }),
-        }),
-        style: DB.Optional({
-            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`). The default is `compressed`.",
-            type: DB.IncludeIdentifier(MapStyle),
-        }),
-        translations: NestedTranslationMap(DB.Optional, "OneTimeCostMap", DB.Object({
-            list_prepend: DB.Optional({
-                comment: "Place a string between the `for` and the grouped map option labels.",
-                type: DB.IncludeIdentifier(ResponsiveTextOptional),
-            }),
-            list_append: DB.Optional({
-                comment: "Place a string after the grouped map option labels.",
-                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.",
-                type: DB.IncludeIdentifier(ResponsiveTextOptional),
-            }),
-        }, { minProperties: 1 })),
-    }),
-});
-const OneTimeCostMapOption = DB.TypeAlias(import.meta.url, {
-    name: "OneTimeCostMapOption",
-    type: () => DB.Object({
-        value: DB.Required({
-            comment: "The full cost value for this option.",
-            type: DB.Integer({ minimum: 1 }),
-        }),
-        permanent_value: DB.Optional({
-            comment: "The part of the `value` that has to be paid permanently.",
-            type: DB.Integer({ minimum: 0 }),
-        }),
-        translations: NestedTranslationMap(DB.Optional, "OneTimeCostMapOption", DB.Object({
-            label: DB.Required({
-                comment: "The description of the option for cost string generation.",
-                type: DB.IncludeIdentifier(ResponsiveTextOptional),
-            }),
-            label_standalone: 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),
-            }),
-        })),
-    }),
-});
-export const MapStyle = DB.Enum(import.meta.url, {
-    name: "MapStyle",
-    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 }),
+        Modifiable: DB.EnumCase({ type: DB.IncludeIdentifier(ModifiableOneTimeCostMap) }),
+        NonModifiable: DB.EnumCase({ type: DB.IncludeIdentifier(NonModifiableOneTimeCostMap) }),
     }),
 });
 export const SustainedCost = DB.Enum(import.meta.url, {
     name: "SustainedCost",
+    values: () => ({
+        Single: DB.EnumCase({ type: DB.IncludeIdentifier(SingleSustainedCost) }),
+        Map: DB.EnumCase({ type: DB.IncludeIdentifier(SustainedCostMap) }),
+    }),
+});
+const SingleSustainedCost = DB.Enum(import.meta.url, {
+    name: "SingleSustainedCost",
     values: () => ({
         Modifiable: DB.EnumCase({ type: DB.IncludeIdentifier(ModifiableSustainedCost) }),
         NonModifiable: DB.EnumCase({ type: DB.IncludeIdentifier(NonModifiableSustainedCost) }),
-        Map: DB.EnumCase({ type: DB.IncludeIdentifier(SustainedCostMap) }),
+    }),
+});
+const SustainedCostMap = DB.Enum(import.meta.url, {
+    name: "SustainedCostMap",
+    values: () => ({
+        Modifiable: DB.EnumCase({ type: DB.IncludeIdentifier(ModifiableSustainedCostMap) }),
+        NonModifiable: DB.EnumCase({ type: DB.IncludeIdentifier(NonModifiableSustainedCostMap) }),
     }),
 });
 const ModifiableSustainedCost = DB.TypeAlias(import.meta.url, {
@@ -231,54 +176,108 @@ const NonModifiableSustainedCostPerCountable = DB.TypeAlias(import.meta.url, {
         })),
     }),
 });
-export const SustainedCostMap = DB.TypeAlias(import.meta.url, {
-    name: "SustainedCostMap",
-    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.`,
+const ModifiableOneTimeCostMap = DB.TypeAlias(import.meta.url, {
+    name: "ModifiableOneTimeCostMap",
     type: () => DB.Object({
-        options: DB.Required({
-            comment: "The possible costs and associated labels.",
-            type: DB.Array(DB.IncludeIdentifier(SustainedCostMapOption), {
-                minItems: 2,
-            }),
+        map: DB.Required({
+            comment: "The cost map.",
+            type: DB.GenIncludeIdentifier(ParameterMap, [
+                DB.IncludeIdentifier(ModifiableOneTimeCostMapOptionValue),
+            ]),
+        }),
+    }),
+});
+const NonModifiableOneTimeCostMap = DB.TypeAlias(import.meta.url, {
+    name: "NonModifiableOneTimeCostMap",
+    type: () => DB.Object({
+        map: DB.Required({
+            comment: "The cost map.",
+            type: DB.GenIncludeIdentifier(ParameterMap, [
+                DB.IncludeIdentifier(NonModifiableOneTimeCostMapOptionValue),
+            ]),
+        }),
+    }),
+});
+/**
+ * Based on the cost map, but for other entries that do not care about modifiability and one-time/sustained differences.
+ */
+export const StandaloneCostMap = DB.TypeAlias(import.meta.url, {
+    name: "StandaloneCostMap",
+    type: () => DB.GenIncludeIdentifier(ParameterMap, [
+        DB.IncludeIdentifier(NonModifiableOneTimeCostMapOptionValue),
+    ]),
+});
+const ModifiableSustainedCostMap = DB.TypeAlias(import.meta.url, {
+    name: "ModifiableSustainedCostMap",
+    type: () => DB.Object({
+        map: DB.Required({
+            comment: "The cost map.",
+            type: DB.GenIncludeIdentifier(ParameterMap, [
+                DB.IncludeIdentifier(ModifiableSustainedCostMapOptionValue),
+            ]),
         }),
         interval: DB.Required({
             comment: "The sustain interval.",
             type: DB.IncludeIdentifier(DurationUnitValue),
         }),
-        translations: NestedTranslationMap(DB.Optional, "SustainedCostMap", DB.Object({
-            listPrefix: DB.Optional({
-                comment: "Place a string between the `for` and the grouped map option labels.",
-                type: DB.IncludeIdentifier(ResponsiveTextOptional),
-            }),
-            listSuffix: DB.Optional({
-                comment: "Place a string after the grouped map option labels.",
-                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.",
-                type: DB.IncludeIdentifier(ResponsiveTextOptional),
-            }),
-        }, { minProperties: 1 })),
     }),
 });
-const SustainedCostMapOption = DB.TypeAlias(import.meta.url, {
-    name: "SustainedCostMapOption",
+const NonModifiableSustainedCostMap = DB.TypeAlias(import.meta.url, {
+    name: "NonModifiableSustainedCostMap",
+    type: () => DB.Object({
+        map: DB.Required({
+            comment: "The cost map.",
+            type: DB.GenIncludeIdentifier(ParameterMap, [
+                DB.IncludeIdentifier(NonModifiableSustainedCostMapOptionValue),
+            ]),
+        }),
+        interval: DB.Required({
+            comment: "The sustain interval.",
+            type: DB.IncludeIdentifier(DurationUnitValue),
+        }),
+    }),
+});
+const ModifiableOneTimeCostMapOptionValue = DB.TypeAlias(import.meta.url, {
+    name: "ModifiableOneTimeCostMapOptionValue",
+    type: () => DB.Object({
+        initialModificationLevel: DB.Required({
+            comment: "The initial skill modification identifier/level.",
+            type: SkillModificationLevelIdentifier(),
+        }),
+        permanentValue: DB.Optional({
+            comment: "The part of the cost value that has to be spent permanently.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+    }),
+});
+const NonModifiableOneTimeCostMapOptionValue = DB.TypeAlias(import.meta.url, {
+    name: "NonModifiableOneTimeCostMapOptionValue",
     type: () => DB.Object({
         value: DB.Required({
-            comment: "The activation cost value for this option. The interval cost is always half of this value.",
+            comment: "The full cost value for this option.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        permanentValue: DB.Optional({
+            comment: "The part of the cost value that has to be spent permanently.",
+            type: DB.Integer({ minimum: 0 }),
+        }),
+    }),
+});
+const ModifiableSustainedCostMapOptionValue = DB.TypeAlias(import.meta.url, {
+    name: "ModifiableSustainedCostMapOptionValue",
+    type: () => DB.Object({
+        initialModificationLevel: DB.Required({
+            comment: "The initial skill modification identifier/level.",
+            type: SkillModificationLevelIdentifier(),
+        }),
+    }),
+});
+const NonModifiableSustainedCostMapOptionValue = DB.TypeAlias(import.meta.url, {
+    name: "NonModifiableSustainedCostMapOptionValue",
+    type: () => DB.Object({
+        value: DB.Required({
+            comment: "The full cost value for this option.",
             type: DB.Integer({ minimum: 1 }),
         }),
-        translations: NestedTranslationMap(DB.Optional, "SustainedCostMapOption", 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),
-            }),
-        })),
     }),
 });

package/lib/types/_ActivatableSkillDuration.d.ts

@@ -15,6 +15,16 @@ export declare const DurationForOneTime: DB.Enum<"DurationForOneTime", {
                 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>;
         translations: DB.MemberDecl<DB.NestedEntityMap<"ImmediateTranslation", {
@@ -47,6 +57,16 @@ export declare const DurationForOneTime: DB.Enum<"DurationForOneTime", {
             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>;
         translations: DB.MemberDecl<DB.NestedEntityMap<"ExpressionBasedDurationTranslation", {
             replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
@@ -79,6 +99,16 @@ export declare const FixedDuration: DB.TypeAlias<"FixedDuration", DB.Object<{
         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>;
     translations: DB.MemberDecl<DB.NestedEntityMap<"FixedDurationTranslation", {
         replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
@@ -102,6 +132,16 @@ export declare const ExpressionBasedDuration: DB.TypeAlias<"ExpressionBasedDurat
         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>;
     translations: DB.MemberDecl<DB.NestedEntityMap<"ExpressionBasedDurationTranslation", {
         replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
@@ -133,6 +173,16 @@ export declare const DurationForSustained: DB.TypeAlias<"DurationForSustained",
             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>;
 }>, []>;
@@ -148,6 +198,16 @@ export declare const DurationUnit: DB.Enum<"DurationUnit", {
     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>;
+    }>, []>>>;
 }, []>;
 export declare const DurationUnitValue: DB.TypeAlias<"DurationUnitValue", DB.Object<{
     value: DB.MemberDecl<DB.Integer, true>;
@@ -163,5 +223,15 @@ export declare const DurationUnitValue: DB.TypeAlias<"DurationUnitValue", DB.Obj
         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>;
 }>, []>;

package/lib/types/_ActivatableSkillDuration.js

@@ -117,6 +117,50 @@ export const DurationUnit = DB.Enum(import.meta.url, {
         Centuries: DB.EnumCase({ type: null }),
         Actions: DB.EnumCase({ type: null }),
         CombatRounds: DB.EnumCase({ type: null }),
+        Custom: DB.EnumCase({
+            type: DB.IncludeIdentifier(CustomDurationUnit),
+        }),
+    }),
+});
+const CustomDurationUnit = DB.TypeAlias(import.meta.url, {
+    name: "CustomDurationUnit",
+    type: () => DB.Object({
+        translations: NestedTranslationMap(DB.Required, "CustomDurationUnit", DB.Object({
+            name: DB.Required({
+                comment: "The name of the custom duration unit.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            fullNumber: DB.Required({
+                comment: "A translation for a numeric value of the custom duration unit, e.g. ‘3 days’. The translation string can and should make use of the `$value` and `$style` variables. The `$style` variable can be either `interval` or `default`.",
+                type: DB.String({
+                    minLength: 1,
+                    pattern: /^\.input \{\$value :number\}[\n ]\.input \{\$style :string\}/,
+                }),
+            }),
+            full: DB.Required({
+                comment: "A translation for an arbitrary value of the custom duration unit, e.g. ‘3–4 days’ or ‘QL days’. The translation string can and should make use of the `$value` variable.",
+                type: DB.String({
+                    minLength: 1,
+                }),
+            }),
+            symbol: DB.Required({
+                comment: "A symbol or shortened label for the custom duration unit for use in small spaces.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            compressedNumber: DB.Required({
+                comment: "A translation for a numeric value of the custom duration unit for use in small spaces, e.g. ‘3 d.’. The translation string can and should make use of the `$value` and `$style` variables. The `$style` variable can be either `interval` or `default`.",
+                type: DB.String({
+                    minLength: 1,
+                    pattern: /^\.input \{\$value :number\}[\n ]\.input \{\$style :string\}/,
+                }),
+            }),
+            compressed: DB.Required({
+                comment: "A translation for an arbitrary value of the custom duration unit for use in small spaces, e.g. ‘3–4 d.’ or ‘QL d.’. The translation string can and should make use of the `$value` variable.",
+                type: DB.String({
+                    minLength: 1,
+                }),
+            }),
+        })),
     }),
 });
 export const DurationUnitValue = DB.TypeAlias(import.meta.url, {

package/lib/types/_ActivatableSkillParameterMap.d.ts

@@ -0,0 +1,34 @@
+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", {
+        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>;
+        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>;
+}>, [Value: DB.Param<"Value", DB.Type>]>;

package/lib/types/_ActivatableSkillParameterMap.js

@@ -0,0 +1,64 @@
+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")],
+    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({
+        options: DB.Required({
+            comment: "The possible values and associated labels.",
+            type: DB.Array(DB.GenIncludeIdentifier(ParameterMapOption, [DB.TypeArgument(Value)]), {
+                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),
+        }),
+        translations: NestedTranslationMap(DB.Optional, "ParameterMap", DB.Object({
+            listPrefix: DB.Optional({
+                comment: "Place a string between the `for` and the grouped map option labels.",
+                type: DB.IncludeIdentifier(ResponsiveTextOptional),
+            }),
+            listSuffix: DB.Optional({
+                comment: "Place a string after the grouped map option labels.",
+                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.",
+                type: DB.IncludeIdentifier(ResponsiveTextOptional),
+            }),
+        }, { minProperties: 1 })),
+    }),
+});
+const ParameterMapStyle = DB.Enum(import.meta.url, {
+    name: "ParameterMapStyle",
+    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({
+            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),
+            }),
+        })),
+    }),
+});