@optolith/database-schema 0.42.1

package/lib/types/_ActivatableSkill.js

@@ -0,0 +1,89 @@
+/**
+ * @title Activatable Skill
+ */
+import * as DB from "tsondb/schema/dsl";
+import { FastCastingTime, SlowCastingTime } from "./_ActivatableSkillCastingTime.js";
+import { OneTimeCost, SustainedCost } from "./_ActivatableSkillCost.js";
+import { DurationForOneTime, DurationForSustained } from "./_ActivatableSkillDuration.js";
+import { Range } from "./_ActivatableSkillRange.js";
+export const OneTimePerformanceParameters = DB.GenTypeAlias(import.meta.url, {
+    name: "OneTimePerformanceParameters",
+    parameters: [DB.Param("CastingTime")],
+    type: CastingTime => DB.Object({
+        casting_time: DB.Required({
+            type: DB.TypeArgument(CastingTime),
+        }),
+        cost: DB.Required({
+            type: DB.IncludeIdentifier(OneTimeCost),
+        }),
+        range: DB.Required({
+            type: DB.IncludeIdentifier(Range),
+        }),
+        duration: DB.Required({
+            type: DB.IncludeIdentifier(DurationForOneTime),
+        }),
+    }),
+});
+const SustainedPerformanceParameters = DB.GenTypeAlias(import.meta.url, {
+    name: "SustainedPerformanceParameters",
+    parameters: [DB.Param("CastingTime")],
+    type: CastingTime => DB.Object({
+        casting_time: DB.Required({
+            type: DB.TypeArgument(CastingTime),
+        }),
+        cost: DB.Required({
+            type: DB.IncludeIdentifier(SustainedCost),
+        }),
+        range: DB.Required({
+            type: DB.IncludeIdentifier(Range),
+        }),
+        duration: DB.Optional({
+            type: DB.IncludeIdentifier(DurationForSustained),
+        }),
+    }),
+});
+export const FastPerformanceParameters = DB.Enum(import.meta.url, {
+    name: "FastPerformanceParameters",
+    values: () => ({
+        OneTime: DB.EnumCase({ type: DB.IncludeIdentifier(FastOneTimePerformanceParameters) }),
+        Sustained: DB.EnumCase({ type: DB.IncludeIdentifier(FastSustainedPerformanceParameters) }),
+    }),
+});
+const FastOneTimePerformanceParameters = DB.TypeAlias(import.meta.url, {
+    name: "FastOneTimePerformanceParameters",
+    type: () => DB.GenIncludeIdentifier(OneTimePerformanceParameters, [DB.IncludeIdentifier(FastCastingTime)]),
+});
+const FastSustainedPerformanceParameters = DB.TypeAlias(import.meta.url, {
+    name: "FastSustainedPerformanceParameters",
+    type: () => DB.GenIncludeIdentifier(SustainedPerformanceParameters, [
+        DB.IncludeIdentifier(FastCastingTime),
+    ]),
+});
+export const SlowPerformanceParameters = DB.Enum(import.meta.url, {
+    name: "SlowPerformanceParameters",
+    values: () => ({
+        OneTime: DB.EnumCase({ type: DB.IncludeIdentifier(SlowOneTimePerformanceParameters) }),
+        Sustained: DB.EnumCase({ type: DB.IncludeIdentifier(SlowSustainedPerformanceParameters) }),
+    }),
+});
+const SlowOneTimePerformanceParameters = DB.TypeAlias(import.meta.url, {
+    name: "SlowOneTimePerformanceParameters",
+    type: () => DB.GenIncludeIdentifier(OneTimePerformanceParameters, [DB.IncludeIdentifier(SlowCastingTime)]),
+});
+const SlowSustainedPerformanceParameters = DB.TypeAlias(import.meta.url, {
+    name: "SlowSustainedPerformanceParameters",
+    type: () => DB.GenIncludeIdentifier(SustainedPerformanceParameters, [
+        DB.IncludeIdentifier(SlowCastingTime),
+    ]),
+});
+export const OldParameter = DB.TypeAlias(import.meta.url, {
+    name: "OldParameter",
+    type: () => DB.Object({
+        full: DB.Required({
+            type: DB.String(),
+        }),
+        abbr: DB.Required({
+            type: DB.String(),
+        }),
+    }),
+});

package/lib/types/_ActivatableSkillApplicationsAndUses.d.ts

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

package/lib/types/_ActivatableSkillApplicationsAndUses.js

@@ -0,0 +1,80 @@
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "./Locale.js";
+import { SkillIdentifier } from "./_Identifier.js";
+import { NewSkillApplicationOrUseParentIdentifier } from "./_IdentifierGroup.js";
+export const NewSkillApplication = DB.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: () => DB.Object({
+        parent: DB.Required({
+            comment: "The entry that enables the new skill application.",
+            type: DB.IncludeIdentifier(NewSkillApplicationOrUseParentIdentifier),
+        }),
+        skills: DB.Required({
+            comment: "The skill(s) this application belongs to.",
+            type: DB.Array(SkillIdentifier(), { minItems: 1 }),
+        }),
+        required_skill_rating: DB.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: DB.Integer({ minimum: 1 }),
+        }),
+        translations: NestedTranslationMap(DB.Optional, "NewSkillApplication", DB.Object({
+            name: DB.Required({
+                comment: "The name of the application if different from the activatable entry’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    parentReferenceKey: "parent",
+    instanceDisplayName: {},
+    instanceDisplayNameCustomizer: ({ instance, instanceDisplayName, instanceDisplayNameLocaleId, getDisplayNameForInstanceId, }) => ({
+        name: instanceDisplayName.length > 0
+            ? instanceDisplayName
+            : (getDisplayNameForInstanceId(instance.parent)?.name ?? ""),
+        localeId: instanceDisplayNameLocaleId,
+    }),
+});
+export const skill_applications = DB.Required({
+    displayName: "New Skill Applications",
+    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: DB.ChildEntities(NewSkillApplication),
+});
+export const SkillUse = DB.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: () => DB.Object({
+        parent: DB.Required({
+            comment: "The entry that enables the use.",
+            type: DB.IncludeIdentifier(NewSkillApplicationOrUseParentIdentifier),
+        }),
+        skills: DB.Required({
+            comment: "The skill(s) this use belongs to.",
+            type: DB.Array(SkillIdentifier(), { minItems: 1 }),
+        }),
+        required_skill_rating: DB.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: DB.Integer({ minimum: 1 }),
+        }),
+        translations: NestedTranslationMap(DB.Optional, "SkillUse", DB.Object({
+            name: DB.Required({
+                comment: "The name of the use if different from the activatable entry’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    parentReferenceKey: "parent",
+    instanceDisplayName: {},
+    instanceDisplayNameCustomizer: ({ instance, instanceDisplayName, instanceDisplayNameLocaleId, getDisplayNameForInstanceId, }) => ({
+        name: instanceDisplayName.length > 0
+            ? instanceDisplayName
+            : (getDisplayNameForInstanceId(instance.parent)?.name ?? ""),
+        localeId: instanceDisplayNameLocaleId,
+    }),
+});
+export const skill_uses = DB.Required({
+    displayName: "Skill Uses",
+    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: DB.ChildEntities(SkillUse),
+});

package/lib/types/_ActivatableSkillCastingTime.d.ts

@@ -0,0 +1,66 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const CastingTime: DB.Enum<"CastingTime", {
+    Modifiable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ModifiableCastingTime", DB.Object<{
+        initial_modification_level: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    }>, []>>>;
+    NonModifiable: DB.EnumCase<DB.TypeArgument<DB.Param<"NonModifiable", DB.Type>>>;
+}, [NonModifiable: DB.Param<"NonModifiable", DB.Type>]>;
+export declare const CastingTimeIncludingLovemaking: DB.TypeAlias<"CastingTimeIncludingLovemaking", DB.Object<{
+    default: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"CastingTime", {
+        Modifiable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ModifiableCastingTime", DB.Object<{
+            initial_modification_level: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        }>, []>>>;
+        NonModifiable: DB.EnumCase<DB.TypeArgument<DB.Param<"NonModifiable", DB.Type>>>;
+    }, [NonModifiable: DB.Param<"NonModifiable", DB.Type>]>>, false>;
+    during_lovemaking: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CastingTimeDuringLovemaking", DB.Object<{
+        value: DB.MemberDecl<DB.Integer, true>;
+        unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CastingTimeDuringLovemakingUnit", {
+            SeductionActions: DB.EnumCase<null>;
+            Rounds: DB.EnumCase<null>;
+        }, []>>, true>;
+    }>, []>>, false>;
+}>, [NonModifiable: DB.Param<"NonModifiable", DB.Type>]>;
+export declare const CastingTimeDuringLovemaking: DB.TypeAlias<"CastingTimeDuringLovemaking", DB.Object<{
+    value: DB.MemberDecl<DB.Integer, true>;
+    unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CastingTimeDuringLovemakingUnit", {
+        SeductionActions: DB.EnumCase<null>;
+        Rounds: DB.EnumCase<null>;
+    }, []>>, true>;
+}>, []>;
+export declare const SlowSkillNonModifiableCastingTime: DB.TypeAlias<"SlowSkillNonModifiableCastingTime", DB.Object<{
+    value: DB.MemberDecl<DB.Integer, true>;
+    unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SlowSkillCastingTimeUnit", {
+        Minutes: DB.EnumCase<null>;
+        Hours: DB.EnumCase<null>;
+    }, []>>, true>;
+}>, []>;
+export declare const FastCastingTime: DB.TypeAlias<"FastCastingTime", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"CastingTimeIncludingLovemaking", DB.Object<{
+    default: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"CastingTime", {
+        Modifiable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ModifiableCastingTime", DB.Object<{
+            initial_modification_level: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        }>, []>>>;
+        NonModifiable: DB.EnumCase<DB.TypeArgument<DB.Param<"NonModifiable", DB.Type>>>;
+    }, [NonModifiable: DB.Param<"NonModifiable", DB.Type>]>>, false>;
+    during_lovemaking: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CastingTimeDuringLovemaking", DB.Object<{
+        value: DB.MemberDecl<DB.Integer, true>;
+        unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CastingTimeDuringLovemakingUnit", {
+            SeductionActions: DB.EnumCase<null>;
+            Rounds: DB.EnumCase<null>;
+        }, []>>, true>;
+    }>, []>>, false>;
+}>, [NonModifiable: DB.Param<"NonModifiable", DB.Type>]>>, []>;
+export declare const SlowCastingTime: DB.TypeAlias<"SlowCastingTime", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"CastingTimeIncludingLovemaking", DB.Object<{
+    default: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"CastingTime", {
+        Modifiable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ModifiableCastingTime", DB.Object<{
+            initial_modification_level: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        }>, []>>>;
+        NonModifiable: DB.EnumCase<DB.TypeArgument<DB.Param<"NonModifiable", DB.Type>>>;
+    }, [NonModifiable: DB.Param<"NonModifiable", DB.Type>]>>, false>;
+    during_lovemaking: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CastingTimeDuringLovemaking", DB.Object<{
+        value: DB.MemberDecl<DB.Integer, true>;
+        unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CastingTimeDuringLovemakingUnit", {
+            SeductionActions: DB.EnumCase<null>;
+            Rounds: DB.EnumCase<null>;
+        }, []>>, true>;
+    }>, []>>, false>;
+}>, [NonModifiable: DB.Param<"NonModifiable", DB.Type>]>>, []>;

package/lib/types/_ActivatableSkillCastingTime.js

@@ -0,0 +1,92 @@
+import * as DB from "tsondb/schema/dsl";
+import { SlowSkillCastingTimeUnit } from "./SkillModificationLevel.js";
+import { SkillModificationLevelIdentifier } from "./_Identifier.js";
+export const CastingTime = DB.GenEnum(import.meta.url, {
+    name: "CastingTime",
+    parameters: [DB.Param("NonModifiable")],
+    values: NonModifiable => ({
+        Modifiable: DB.EnumCase({ type: DB.IncludeIdentifier(ModifiableCastingTime) }),
+        NonModifiable: DB.EnumCase({ type: DB.TypeArgument(NonModifiable) }),
+    }),
+});
+const ModifiableCastingTime = DB.TypeAlias(import.meta.url, {
+    name: "ModifiableCastingTime",
+    type: () => DB.Object({
+        initial_modification_level: DB.Required({
+            comment: "The initial skill modification identifier/level.",
+            type: SkillModificationLevelIdentifier(),
+        }),
+    }),
+});
+export const CastingTimeIncludingLovemaking = DB.GenTypeAlias(import.meta.url, {
+    name: "CastingTimeIncludingLovemaking",
+    comment: `The casting time may have two different values: One for use in “normal” time, i. e. actions, combat rounds and others, and one for use during lovemaking, which is a rule set from Aventurian Intimacy.
+
+There must always be at least one casting time value.`,
+    parameters: [DB.Param("NonModifiable")],
+    type: NonModifiable => DB.Object({
+        default: DB.Optional({
+            comment: "The default casting time definition.",
+            type: DB.GenIncludeIdentifier(CastingTime, [DB.TypeArgument(NonModifiable)]),
+        }),
+        during_lovemaking: DB.Optional({
+            comment: "The casting time during lovemaking. In Aventurian Intimacy, you may only use an activatable skill during lovemaking if it has a casting time used during lovemaking.",
+            type: DB.IncludeIdentifier(CastingTimeDuringLovemaking),
+        }),
+    }, { minProperties: 1 }),
+});
+export const CastingTimeDuringLovemaking = DB.TypeAlias(import.meta.url, {
+    name: "CastingTimeDuringLovemaking",
+    comment: "The casting time during lovemaking. In Aventurian Intimacy, you may only use an activatable skill during lovemaking if it has a casting time used during lovemaking.",
+    type: () => DB.Object({
+        value: DB.Required({
+            comment: "The (unitless) casting time value.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        unit: DB.Required({
+            comment: "The unit of the `value`.",
+            type: DB.IncludeIdentifier(CastingTimeDuringLovemakingUnit),
+        }),
+    }),
+});
+const CastingTimeDuringLovemakingUnit = DB.Enum(import.meta.url, {
+    name: "CastingTimeDuringLovemakingUnit",
+    values: () => ({
+        SeductionActions: DB.EnumCase({ type: null }),
+        Rounds: DB.EnumCase({ type: null }),
+    }),
+});
+const FastSkillNonModifiableCastingTime = DB.TypeAlias(import.meta.url, {
+    name: "FastSkillNonModifiableCastingTime",
+    type: () => DB.Object({
+        actions: DB.Required({
+            comment: "The casting time value in actions.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+    }),
+});
+export const SlowSkillNonModifiableCastingTime = DB.TypeAlias(import.meta.url, {
+    name: "SlowSkillNonModifiableCastingTime",
+    type: () => DB.Object({
+        value: DB.Required({
+            comment: "The (unitless) casting time value.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        unit: DB.Required({
+            comment: "The unit of the `value`.",
+            type: DB.IncludeIdentifier(SlowSkillCastingTimeUnit),
+        }),
+    }),
+});
+export const FastCastingTime = DB.TypeAlias(import.meta.url, {
+    name: "FastCastingTime",
+    type: () => DB.GenIncludeIdentifier(CastingTimeIncludingLovemaking, [
+        DB.IncludeIdentifier(FastSkillNonModifiableCastingTime),
+    ]),
+});
+export const SlowCastingTime = DB.TypeAlias(import.meta.url, {
+    name: "SlowCastingTime",
+    type: () => DB.GenIncludeIdentifier(CastingTimeIncludingLovemaking, [
+        DB.IncludeIdentifier(SlowSkillNonModifiableCastingTime),
+    ]),
+});

package/lib/types/_ActivatableSkillCheckResultBased.d.ts

@@ -0,0 +1,27 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const CheckResultValue: DB.Enum<"CheckResultValue", {
+    QualityLevels: DB.EnumCase<null>;
+    SkillPoints: DB.EnumCase<null>;
+    SkillRating: DB.EnumCase<null>;
+}, []>;
+export declare const CheckResultBasedModifier: DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
+    arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {
+        Multiply: DB.EnumCase<null>;
+        Divide: DB.EnumCase<null>;
+    }, []>>, true>;
+    value: DB.MemberDecl<DB.Integer, true>;
+}>, []>;
+export declare const CheckResultBased: DB.TypeAlias<"CheckResultBased", DB.Object<{
+    base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
+        QualityLevels: DB.EnumCase<null>;
+        SkillPoints: DB.EnumCase<null>;
+        SkillRating: DB.EnumCase<null>;
+    }, []>>, true>;
+    modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
+        arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {
+            Multiply: DB.EnumCase<null>;
+            Divide: DB.EnumCase<null>;
+        }, []>>, true>;
+        value: DB.MemberDecl<DB.Integer, true>;
+    }>, []>>, false>;
+}>, []>;

package/lib/types/_ActivatableSkillCheckResultBased.js

@@ -0,0 +1,45 @@
+import * as DB from "tsondb/schema/dsl";
+export const CheckResultValue = DB.Enum(import.meta.url, {
+    name: "CheckResultValue",
+    comment: "Defines the derived (unitless) value.",
+    values: () => ({
+        QualityLevels: DB.EnumCase({ type: null }),
+        SkillPoints: DB.EnumCase({ type: null }),
+        SkillRating: DB.EnumCase({ type: null }),
+    }),
+});
+const CheckResultArithmetic = DB.Enum(import.meta.url, {
+    name: "CheckResultArithmetic",
+    comment: "Defines how the the `value` is set off against the check result.",
+    values: () => ({
+        Multiply: DB.EnumCase({ type: null }),
+        Divide: DB.EnumCase({ type: null }),
+    }),
+});
+export const CheckResultBasedModifier = DB.TypeAlias(import.meta.url, {
+    name: "CheckResultBasedModifier",
+    type: () => DB.Object({
+        arithmetic: DB.Required({
+            comment: "The arithmetic how to apply the `value` to the `base`.",
+            type: DB.IncludeIdentifier(CheckResultArithmetic),
+        }),
+        value: DB.Required({
+            comment: "The value that is applied to the `base` using the defined `arithmetic`.",
+            type: DB.Integer({ minimum: 2 }),
+        }),
+    }),
+});
+export const CheckResultBased = DB.TypeAlias(import.meta.url, {
+    name: "CheckResultBased",
+    comment: "Defines a parameter being based on a check result.",
+    type: () => DB.Object({
+        base: DB.Required({
+            comment: "The base value that is derived from the check result.",
+            type: DB.IncludeIdentifier(CheckResultValue),
+        }),
+        modifier: DB.Optional({
+            comment: "If defined, it modifies the base value.",
+            type: DB.IncludeIdentifier(CheckResultBasedModifier),
+        }),
+    }),
+});