optolith-database-schema 0.21.1 → 0.22.0

package/lib/types/_ActivatableSelectOptions.js

@@ -0,0 +1,272 @@
+import { Boolean, ChildEntities, Entity, Enum, EnumCase, getAnyEnumCaseValue, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
+import { NestedTranslationMap } from "./Locale.js";
+import { SelectOptionCategory } from "./_ActivatableSelectOptionCategory.js";
+import { NewSkillApplication, SkillUse } from "./_ActivatableSkillApplicationsAndUses.js";
+import { GeneralIdentifier, SkillIdentifier } from "./_Identifier.js";
+import { CombatTechniqueIdentifier, SelectOptionParentIdentifier } from "./_IdentifierGroup.js";
+import { GeneralPrerequisites } from "./_Prerequisite.js";
+import { Errata } from "./source/_Erratum.js";
+import { optionalSrc } from "./source/_PublicationRef.js";
+const SelectOptions = TypeAlias(import.meta.url, {
+    name: "SelectOptions",
+    comment: `Definitions for possible options for the activatable entry. They can either be derived from entry categories or be defined explicitly. Both can happen as well, but if there is an explicitly defined select option and a derived select option has the same identifier (which may only happen if skill or combat technique identifiers are used for explicit select options), the explicit definition overwrites the derived option.
+
+Note that this is only a full definition of options for simple logic that can be made explicit using the more detailed configuration for both derived categories and explicit options. There are quite a few entries whose option logic cannot be fully represented here, so that it needs to be implemented manually.`,
+    type: () => Object({
+        derived: Optional({
+            comment: `An entry category with optional further configuration. All available entries from the specified categories will be included as separate select options. You can also specify a set of groups that should only be included. Groups not mentioned will be excluded then.`,
+            type: IncludeIdentifier(SelectOptionCategory),
+        }),
+    }, { minProperties: 1 }),
+});
+export const select_options = Optional({
+    comment: `Definitions for possible options for the activatable entry, derived from entry categories.
+
+Note that this is only a full definition of options for simple logic that can be made explicit using the more detailed configuration for both derived categories and explicit options. There are quite a few entries whose option logic cannot be fully represented here, so that it needs to be implemented manually.`,
+    type: IncludeIdentifier(SelectOptions),
+});
+export const ExplicitSelectOption = Enum(import.meta.url, {
+    name: "ExplicitSelectOption",
+    values: () => ({
+        General: EnumCase({ type: GeneralIdentifier() }),
+        Skill: EnumCase({ type: IncludeIdentifier(ExplicitSkillSelectOption) }),
+        CombatTechnique: EnumCase({ type: IncludeIdentifier(ExplicitCombatTechniqueSelectOption) }),
+    }),
+});
+export const GeneralSelectOption = Entity(import.meta.url, {
+    name: "GeneralSelectOption",
+    namePlural: "GeneralSelectOptions",
+    type: () => Object({
+        parent: Required({
+            comment: "The entry that contains select option.",
+            type: IncludeIdentifier(SelectOptionParentIdentifier),
+        }),
+        profession_only: Optional({
+            comment: "Sometimes, professions use specific text selections that are not contained in described lists. This ensures you can use them for professions only. They are not going to be displayed as options to the user.",
+            type: Boolean(),
+        }),
+        skill_applications: Required({
+            comment: "Registers new applications, which get enabled once this entry is activated with its respective select option. It specifies an entry-unique identifier and the skill it belongs to. A translation can be left out if its name equals the name of the origin select option.",
+            type: ChildEntities(NewSkillApplication),
+        }),
+        skill_uses: Required({
+            comment: "Registers uses, which get enabled once this entry is activated with its respective select option. It specifies an entry-unique identifier and the skill it belongs to. A translation can be left out if its name equals the name of the origin select option.",
+            type: ChildEntities(SkillUse),
+        }),
+        prerequisites: Optional({
+            comment: "Prerequisites for the select option.",
+            type: IncludeIdentifier(GeneralPrerequisites),
+        }),
+        binding_cost: Optional({
+            comment: "Specific binding cost for the select option. Only has an effect if the associated entry supports binding costs.",
+            type: Integer({ minimum: 0 }),
+        }),
+        ap_value: Optional({
+            comment: "Specific AP cost for the select option.",
+            type: Integer({ minimum: 1 }),
+        }),
+        src: optionalSrc,
+        translations: NestedTranslationMap(Required, "GeneralSelectOption", Object({
+            name: Required({
+                comment: "The name of the select option.",
+                type: String({ minLength: 1 }),
+            }),
+            name_in_profession: Optional({
+                comment: "The name of the select option when displayed in a generated profession text.",
+                type: String({ minLength: 1 }),
+            }),
+            description: Optional({
+                comment: "The description of the select option. Useful for Bad Habits, Trade Secrets and other entries where a description is available.",
+                type: String({ minLength: 1, isMarkdown: true }),
+            }),
+            errata: Optional({
+                type: IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    parentReferenceKey: "parent",
+    displayName: {},
+    displayNameCustomizer: ({ instance, instanceDisplayName, instanceDisplayNameLocaleId, getDisplayNameForInstanceId, }) => ({
+        name: `${instanceDisplayName.length > 0
+            ? instanceDisplayName
+            : (getDisplayNameForInstanceId(getAnyEnumCaseValue(instance.parent))?.name ?? "")} — ${instanceDisplayName}`,
+        localeId: instanceDisplayNameLocaleId,
+    }),
+});
+export const explicit_select_options = Required({
+    comment: `Explicit definitions for possible options for the activatable entry.
+
+Note that this is only a full definition of options for simple logic that can be made explicit using the more detailed configuration for both derived categories and explicit options. There are quite a few entries whose option logic cannot be fully represented here, so that it needs to be implemented manually.`,
+    type: ChildEntities(GeneralSelectOption),
+});
+const ExplicitSkillSelectOption = TypeAlias(import.meta.url, {
+    name: "ExplicitSkillSelectOption",
+    type: () => Object({
+        id: Required({
+            comment: "The skill’s identifier.",
+            type: SkillIdentifier(),
+        }),
+        prerequisites: Optional({
+            comment: "Prerequisites for the select option.",
+            type: IncludeIdentifier(GeneralPrerequisites),
+        }),
+        binding_cost: Optional({
+            comment: "Specific binding cost for the select option. Only has an effect if the associated entry supports binding costs.",
+            type: Integer({ minimum: 0 }),
+        }),
+        ap_value: Optional({
+            comment: "Specific AP cost for the select option.",
+            type: Integer({ minimum: 1 }),
+        }),
+        src: optionalSrc,
+        translations: NestedTranslationMap(Optional, "ExplicitSkillSelectOption", Object({
+            errata: Optional({
+                type: IncludeIdentifier(Errata),
+            }),
+        }, { minProperties: 1 })),
+    }),
+});
+const ExplicitCombatTechniqueSelectOption = TypeAlias(import.meta.url, {
+    name: "ExplicitCombatTechniqueSelectOption",
+    type: () => Object({
+        id: Required({
+            comment: "The combat technique’s identifier.",
+            type: IncludeIdentifier(CombatTechniqueIdentifier),
+        }),
+        prerequisites: Optional({
+            comment: "Prerequisites for the select option.",
+            type: IncludeIdentifier(GeneralPrerequisites),
+        }),
+        binding_cost: Optional({
+            comment: "Specific binding cost for the select option. Only has an effect if the associated entry supports binding costs.",
+            type: Integer({ minimum: 0 }),
+        }),
+        ap_value: Optional({
+            comment: "Specific AP cost for the select option.",
+            type: Integer({ minimum: 1 }),
+        }),
+        src: optionalSrc,
+        translations: NestedTranslationMap(Optional, "ExplicitCombatTechniqueSelectOption", Object({
+            errata: Optional({
+                type: IncludeIdentifier(Errata),
+            }),
+        }, { minProperties: 1 })),
+    }),
+});
+// "Options": {
+//   "$comment": "Unfinished generalized options handling.",
+//   "type": "array",
+//   "minItems": 1,
+//   "items": {
+//     "oneOf": [
+//       {
+//         "type": "object",
+//         "properties": {
+//           "type": { "const": "List" },
+//           "value": {
+//             "type": "object",
+//             "properties": {
+//               "list": {
+//                 "oneOf": [
+//                   {
+//                     "type": "object",
+//                     "properties": {
+//                       "type": { "const": "Generate" },
+//                       "value": { "$ref": "#/definitions/SelectOptionCategories" }
+//                     },
+//                     "required": ["type", "value"],
+//                     "additionalProperties": false
+//                   },
+//                   {
+//                     "type": "object",
+//                     "properties": {
+//                       "type": { "const": "Explicit" },
+//                       "value": { "$ref": "#/definitions/SelectOptions" }
+//                     },
+//                     "required": ["type", "value"],
+//                     "additionalProperties": false
+//                   }
+//                 ]
+//               },
+//               "multiple": {
+//                 "description": "Sometimes, multiple options from a single list have to or can be chosen. Its possible to define a number of options that have to be selected or a range of numbers of options that can be selected.",
+//                 "oneOf": [
+//                   {
+//                     "type": "object",
+//                     "properties": {
+//                       "type": { "const": "Fixed" },
+//                       "value": {
+//                         "description": "The number of options that have to be selected.",
+//                         "type": "integer",
+//                         "minimum": 2
+//                       }
+//                     },
+//                     "required": ["type", "value"],
+//                     "additionalProperties": false
+//                   },
+//                   {
+//                     "type": "object",
+//                     "properties": {
+//                       "type": { "const": "Range" },
+//                       "value": {
+//                         "type": "object",
+//                         "properties": {
+//                           "min": {
+//                             "description": "The minimum number of options that need to be selected. If left empty it defaults to 1.",
+//                             "type": "integer",
+//                             "minimum": 2
+//                           },
+//                           "max": {
+//                             "description": "The maximum number of options that need to be selected.",
+//                             "type": "integer",
+//                             "minimum": 2
+//                           }
+//                         },
+//                         "required": ["max"],
+//                         "additionalProperties": false
+//                       }
+//                     },
+//                     "required": ["type", "value"],
+//                     "additionalProperties": false
+//                   }
+//                 ]
+//               }
+//             },
+//             "required": ["list"],
+//             "additionalProperties": false
+//           }
+//         },
+//         "required": ["type", "value"],
+//         "additionalProperties": false
+//       },
+//       {
+//         "type": "object",
+//         "properties": {
+//           "type": { "const": "TextInput" },
+//           "value": {
+//             "type": "object",
+//             "properties": {
+//               "label": {
+//                 "type": "object",
+//                 "description": "All translations for the entry, identified by IETF language tag (BCP47).",
+//                 "patternProperties": {
+//                   "^[a-z]{2}-[A-Z]{2}$": {
+//                     "description": "The text input label.",
+//                     "type": "string",
+//                     "minLength": 1
+//                   }
+//                 },
+//                 "minProperties": 1,
+//                 "additionalProperties": false
+//               }
+//             },
+//             "required": ["label"],
+//             "additionalProperties": false
+//           }
+//         },
+//         "required": ["type", "value"],
+//         "additionalProperties": false
+//       }
+//     ]
+//   }
+// },

package/lib/types/_ActivatableSkillApplicationsAndUses.d.ts

@@ -0,0 +1,109 @@
+import { Array, ChildEntities, Entity, IncludeIdentifier, Integer, String } from "tsondb/schema/def";
+export declare const NewSkillApplication: Entity<"NewSkillApplication", {
+    parent: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"NewSkillApplicationOrUseParentIdentifier", {
+        GeneralSelectOption: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Advantage: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Disadvantage: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AdvancedCombatSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AdvancedKarmaSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AdvancedMagicalSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AdvancedSkillSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        BlessedTradition: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        CeremonialItemSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        CombatSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        CombatStyleSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        FatePointSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        GeneralSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        LiturgicalStyleSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        MagicalSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        MagicalTradition: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        MagicStyleSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        SexSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+    }, []>>, true>;
+    skills: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
+    required_skill_rating: import("tsondb/schema/def").MemberDecl<Integer, false>;
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"NewSkillApplicationTranslation", {
+        name: import("tsondb/schema/def").MemberDecl<String, true>;
+    }>, false>;
+}, "parent">;
+export declare const skill_applications: import("tsondb/schema/def").MemberDecl<ChildEntities<Entity<"NewSkillApplication", {
+    parent: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"NewSkillApplicationOrUseParentIdentifier", {
+        GeneralSelectOption: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Advantage: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Disadvantage: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AdvancedCombatSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AdvancedKarmaSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AdvancedMagicalSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AdvancedSkillSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        BlessedTradition: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        CeremonialItemSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        CombatSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        CombatStyleSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        FatePointSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        GeneralSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        LiturgicalStyleSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        MagicalSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        MagicalTradition: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        MagicStyleSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        SexSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+    }, []>>, true>;
+    skills: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
+    required_skill_rating: import("tsondb/schema/def").MemberDecl<Integer, false>;
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"NewSkillApplicationTranslation", {
+        name: import("tsondb/schema/def").MemberDecl<String, true>;
+    }>, false>;
+}, "parent">>, true>;
+export declare const SkillUse: Entity<"SkillUse", {
+    parent: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"NewSkillApplicationOrUseParentIdentifier", {
+        GeneralSelectOption: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Advantage: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Disadvantage: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AdvancedCombatSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AdvancedKarmaSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AdvancedMagicalSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AdvancedSkillSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        BlessedTradition: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        CeremonialItemSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        CombatSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        CombatStyleSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        FatePointSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        GeneralSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        LiturgicalStyleSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        MagicalSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        MagicalTradition: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        MagicStyleSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        SexSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+    }, []>>, true>;
+    skills: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
+    required_skill_rating: import("tsondb/schema/def").MemberDecl<Integer, false>;
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"SkillUseTranslation", {
+        name: import("tsondb/schema/def").MemberDecl<String, true>;
+    }>, false>;
+}, "parent">;
+export declare const skill_uses: import("tsondb/schema/def").MemberDecl<ChildEntities<Entity<"SkillUse", {
+    parent: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"NewSkillApplicationOrUseParentIdentifier", {
+        GeneralSelectOption: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Advantage: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Disadvantage: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AdvancedCombatSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AdvancedKarmaSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AdvancedMagicalSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        AdvancedSkillSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        BlessedTradition: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        CeremonialItemSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        CombatSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        CombatStyleSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        FatePointSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        GeneralSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        LiturgicalStyleSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        MagicalSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        MagicalTradition: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        MagicStyleSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        SexSpecialAbility: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+    }, []>>, true>;
+    skills: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
+    required_skill_rating: import("tsondb/schema/def").MemberDecl<Integer, false>;
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"SkillUseTranslation", {
+        name: import("tsondb/schema/def").MemberDecl<String, true>;
+    }>, false>;
+}, "parent">>, true>;

package/lib/types/_ActivatableSkillApplicationsAndUses.js

@@ -0,0 +1,78 @@
+import { Array, ChildEntities, Entity, getAnyEnumCaseValue, IncludeIdentifier, Integer, Object, Optional, Required, String, } from "tsondb/schema/def";
+import { NestedTranslationMap } from "./Locale.js";
+import { SkillIdentifier } from "./_Identifier.js";
+import { NewSkillApplicationOrUseParentIdentifier } from "./_IdentifierGroup.js";
+export const NewSkillApplication = Entity(import.meta.url, {
+    name: "NewSkillApplication",
+    namePlural: "NewSkillApplications",
+    comment: "Registers new skill applications, which get enabled once the referenced entry is activated. It specifies the skill(s) it belongs to. A translation can be left out if its name equals the name of the origin activatable entry.",
+    type: () => Object({
+        parent: Required({
+            comment: "The entry that enables the new skill application.",
+            type: IncludeIdentifier(NewSkillApplicationOrUseParentIdentifier),
+        }),
+        skills: Required({
+            comment: "The skill(s) this application belongs to.",
+            type: Array(SkillIdentifier(), { minItems: 1 }),
+        }),
+        required_skill_rating: Optional({
+            comment: "If an application applies to multiple skills, it may need to ensure the respective skill is on a certain skill rating if the activatable entry cannot ensure this prerequisite.",
+            type: Integer({ minimum: 1 }),
+        }),
+        translations: NestedTranslationMap(Optional, "NewSkillApplication", Object({
+            name: Required({
+                comment: "The name of the application if different from the activatable entry’s name.",
+                type: String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    parentReferenceKey: "parent",
+    displayName: {},
+    displayNameCustomizer: ({ instance, instanceDisplayName, instanceDisplayNameLocaleId, getDisplayNameForInstanceId, }) => ({
+        name: instanceDisplayName.length > 0
+            ? instanceDisplayName
+            : (getDisplayNameForInstanceId(getAnyEnumCaseValue(instance.parent))?.name ?? ""),
+        localeId: instanceDisplayNameLocaleId,
+    }),
+});
+export const skill_applications = Required({
+    comment: "Registers new skill applications, which get enabled once this entry is activated. It specifies an entry-unique identifier and the skill it belongs to. A translation can be left out if its name equals the name of the origin activatable entry.",
+    type: ChildEntities(NewSkillApplication),
+});
+export const SkillUse = Entity(import.meta.url, {
+    name: "SkillUse",
+    namePlural: "SkillUses",
+    comment: "Registers uses, which get enabled once this entry is activated. It specifies the skill(s) it belongs to. A translation can be left out if its name equals the name of the origin activatable entry.",
+    type: () => Object({
+        parent: Required({
+            comment: "The entry that enables the use.",
+            type: IncludeIdentifier(NewSkillApplicationOrUseParentIdentifier),
+        }),
+        skills: Required({
+            comment: "The skill(s) this use belongs to.",
+            type: Array(SkillIdentifier(), { minItems: 1 }),
+        }),
+        required_skill_rating: Optional({
+            comment: "If a use applies to multiple skills, it may need to ensure the respective skill is on a certain skill rating if the activatable entry cannot ensure this prerequisite.",
+            type: Integer({ minimum: 1 }),
+        }),
+        translations: NestedTranslationMap(Optional, "SkillUse", Object({
+            name: Required({
+                comment: "The name of the use if different from the activatable entry’s name.",
+                type: String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    parentReferenceKey: "parent",
+    displayName: {},
+    displayNameCustomizer: ({ instance, instanceDisplayName, instanceDisplayNameLocaleId, getDisplayNameForInstanceId, }) => ({
+        name: instanceDisplayName.length > 0
+            ? instanceDisplayName
+            : (getDisplayNameForInstanceId(getAnyEnumCaseValue(instance.parent))?.name ?? ""),
+        localeId: instanceDisplayNameLocaleId,
+    }),
+});
+export const skill_uses = Required({
+    comment: "Registers uses, which get enabled once this entry is activated. It specifies an entry-unique identifier and the skill it belongs to. A translation can be left out if its name equals the name of the origin activatable entry.",
+    type: ChildEntities(SkillUse),
+});

package/lib/types/_Enhancements.js

@@ -1,7 +1,7 @@
 /**
  * @title Enhancements
  */
-import { ChildEntities, Entity, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
+import { ChildEntities, Entity, getAnyEnumCaseValue, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
 import { SkillWithEnhancementsIdentifier } from "./_IdentifierGroup.js";
 import { EnhancementPrerequisites } from "./_Prerequisite.js";
 import { NestedTranslationMap } from "./Locale.js";
@@ -63,7 +63,7 @@ export const Enhancement = Entity(import.meta.url, {
     parentReferenceKey: "parent",
     displayName: {},
     displayNameCustomizer: ({ instance, instanceDisplayName, instanceDisplayNameLocaleId, getDisplayNameForInstanceId, }) => ({
-        name: `${getDisplayNameForInstanceId(instance.parent[instance.parent.kind])?.name} — ${instanceDisplayName}`,
+        name: `${getDisplayNameForInstanceId(getAnyEnumCaseValue(instance.parent))?.name ?? ""} — ${instanceDisplayName}`,
         localeId: instanceDisplayNameLocaleId,
     }),
 });

package/lib/types/_Identifier.js

@@ -1,5 +1,6 @@
 import { ReferenceIdentifier as R } from "tsondb/schema/def";
-import { GeneralSelectOption, NewSkillApplication, SkillUse } from "./_Activatable.js";
+import { GeneralSelectOption } from "./_ActivatableSelectOptions.js";
+import { NewSkillApplication, SkillUse } from "./_ActivatableSkillApplicationsAndUses.js";
 import { Enhancement } from "./_Enhancements.js";
 import { Influence } from "./_Influence.js";
 import { Advantage } from "./Advantage.js";

package/lib/types/_MathExpression.d.ts

@@ -4,7 +4,7 @@ type BinaryMathOperation = {
     [K in BinaryMathOperationName]: EnumCase<Array<IncludeIdentifier<[Value: TypeParameter], MathOperation>>>;
 };
 export type MathOperation = Enum<"MathOperation", {
-    Value: EnumCase<TypeArgument<TypeParameter>>;
+    Value: EnumCase<TypeArgument>;
 } & BinaryMathOperation, [
     Value: TypeParameter
 ]>;

package/lib/types/_SizeCategory.d.ts

@@ -0,0 +1,15 @@
+import { Enum, EnumCase, Object, TypeArgument } from "tsondb/schema/def";
+export declare const SizeCategory: Enum<"SizeCategory", {
+    Tiny: EnumCase<null>;
+    Small: EnumCase<null>;
+    Medium: EnumCase<null>;
+    Large: EnumCase<null>;
+    Huge: EnumCase<null>;
+}, []>;
+export declare const BySizeCategory: import("tsondb/schema/def").TypeAliasDecl<"BySizeCategory", Object<{
+    tiny: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>, true>;
+    small: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>, true>;
+    medium: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>, true>;
+    large: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>, true>;
+    huge: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>, true>;
+}>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>;

package/lib/types/_SizeCategory.js

@@ -0,0 +1,24 @@
+import { Enum, EnumCase, GenTypeAlias, Object, Param, Required, TypeArgument, } from "tsondb/schema/def";
+export const SizeCategory = Enum(import.meta.url, {
+    name: "SizeCategory",
+    comment: "Each creature fits into one of these size categories.",
+    values: () => ({
+        Tiny: EnumCase({ type: null }),
+        Small: EnumCase({ type: null }),
+        Medium: EnumCase({ type: null }),
+        Large: EnumCase({ type: null }),
+        Huge: EnumCase({ type: null }),
+    }),
+});
+export const BySizeCategory = GenTypeAlias(import.meta.url, {
+    name: "BySizeCategory",
+    comment: "An object that holds values for the different size categories",
+    parameters: [Param("T")],
+    type: T => Object({
+        tiny: Required({ type: TypeArgument(T) }),
+        small: Required({ type: TypeArgument(T) }),
+        medium: Required({ type: TypeArgument(T) }),
+        large: Required({ type: TypeArgument(T) }),
+        huge: Required({ type: TypeArgument(T) }),
+    }),
+});

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

@@ -122,7 +122,7 @@ const CostRange = TypeAlias(import.meta.url, {
 export const Weight = TypeAlias(import.meta.url, {
     name: "Weight",
     comment: "The weight in kg.",
-    type: () => Float({ minimum: { value: 0, isExclusive: true } }),
+    type: () => Float({ minimum: { value: 0, isExclusive: true }, fractionDigits: 3 }),
 });
 export const Complexity = Enum(import.meta.url, {
     name: "Complexity",

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

@@ -1,4 +1,4 @@
-import { Enum, EnumCase, IncludeIdentifier, Object, ReferenceIdentifier, String, TypeAlias } from "tsondb/schema/def";
+import { Enum, EnumCase, IncludeIdentifier, Object, type ReferenceIdentifier, String, TypeAlias } from "tsondb/schema/def";
 export declare const MusicTraditionReference: (traditionIdentifier: ReferenceIdentifier) => TypeAlias<string, Object<{
     id: import("tsondb/schema/def").MemberDecl<ReferenceIdentifier, true>;
     translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${string}Translation`, {