@optolith/database-schema 0.42.1

package/lib/types/_ActivatableSkillDuration.d.ts

@@ -0,0 +1,204 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const DurationForOneTime: DB.Enum<"DurationForOneTime", {
+    Immediate: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Immediate", DB.Object<{
+        maximum: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DurationUnitValue", DB.Object<{
+            value: DB.MemberDecl<DB.Integer, true>;
+            unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationUnit", {
+                Seconds: DB.EnumCase<null>;
+                Minutes: DB.EnumCase<null>;
+                Hours: DB.EnumCase<null>;
+                Days: DB.EnumCase<null>;
+                Weeks: DB.EnumCase<null>;
+                Months: DB.EnumCase<null>;
+                Years: DB.EnumCase<null>;
+                Centuries: DB.EnumCase<null>;
+                Actions: DB.EnumCase<null>;
+                CombatRounds: DB.EnumCase<null>;
+            }, []>>, true>;
+        }>, []>>, false>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"ImmediateTranslation", {
+            replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+                full: DB.MemberDecl<DB.String, true>;
+                compressed: DB.MemberDecl<DB.String, true>;
+            }>, []>>, false>;
+        }>, false>;
+    }>, []>>>;
+    Permanent: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PermanentDuration", DB.Object<{
+        translations: DB.MemberDecl<DB.NestedEntityMap<"PermanentDurationTranslation", {
+            replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+                full: DB.MemberDecl<DB.String, true>;
+                compressed: DB.MemberDecl<DB.String, true>;
+            }>, []>>, false>;
+        }>, false>;
+    }>, []>>>;
+    Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedDuration", DB.Object<{
+        is_maximum: DB.MemberDecl<DB.Boolean, false>;
+        value: DB.MemberDecl<DB.Integer, true>;
+        unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationUnit", {
+            Seconds: DB.EnumCase<null>;
+            Minutes: DB.EnumCase<null>;
+            Hours: DB.EnumCase<null>;
+            Days: DB.EnumCase<null>;
+            Weeks: DB.EnumCase<null>;
+            Months: DB.EnumCase<null>;
+            Years: DB.EnumCase<null>;
+            Centuries: DB.EnumCase<null>;
+            Actions: DB.EnumCase<null>;
+            CombatRounds: DB.EnumCase<null>;
+        }, []>>, true>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"FixedDurationTranslation", {
+            replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+                full: DB.MemberDecl<DB.String, true>;
+                compressed: DB.MemberDecl<DB.String, true>;
+            }>, []>>, false>;
+        }>, false>;
+    }>, []>>>;
+    CheckResultBased: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedDuration", DB.Object<{
+        is_maximum: DB.MemberDecl<DB.Boolean, false>;
+        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>;
+        unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationUnit", {
+            Seconds: DB.EnumCase<null>;
+            Minutes: DB.EnumCase<null>;
+            Hours: DB.EnumCase<null>;
+            Days: DB.EnumCase<null>;
+            Weeks: DB.EnumCase<null>;
+            Months: DB.EnumCase<null>;
+            Years: DB.EnumCase<null>;
+            Centuries: DB.EnumCase<null>;
+            Actions: DB.EnumCase<null>;
+            CombatRounds: DB.EnumCase<null>;
+        }, []>>, true>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"CheckResultBasedDurationTranslation", {
+            replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+                full: DB.MemberDecl<DB.String, true>;
+                compressed: DB.MemberDecl<DB.String, true>;
+            }>, []>>, false>;
+        }>, false>;
+    }>, []>>>;
+    Indefinite: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"IndefiniteDuration", DB.Object<{
+        translations: DB.MemberDecl<DB.NestedEntityMap<"IndefiniteDurationTranslation", {
+            description: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveText", DB.Object<{
+                full: DB.MemberDecl<DB.String, true>;
+                compressed: DB.MemberDecl<DB.String, true>;
+            }>, []>>, true>;
+        }>, true>;
+    }>, []>>>;
+}, []>;
+export declare const FixedDuration: DB.TypeAlias<"FixedDuration", DB.Object<{
+    is_maximum: DB.MemberDecl<DB.Boolean, false>;
+    value: DB.MemberDecl<DB.Integer, true>;
+    unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationUnit", {
+        Seconds: DB.EnumCase<null>;
+        Minutes: DB.EnumCase<null>;
+        Hours: DB.EnumCase<null>;
+        Days: DB.EnumCase<null>;
+        Weeks: DB.EnumCase<null>;
+        Months: DB.EnumCase<null>;
+        Years: DB.EnumCase<null>;
+        Centuries: DB.EnumCase<null>;
+        Actions: DB.EnumCase<null>;
+        CombatRounds: DB.EnumCase<null>;
+    }, []>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"FixedDurationTranslation", {
+        replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+            full: DB.MemberDecl<DB.String, true>;
+            compressed: DB.MemberDecl<DB.String, true>;
+        }>, []>>, false>;
+    }>, false>;
+}>, []>;
+export declare const CheckResultBasedDuration: DB.TypeAlias<"CheckResultBasedDuration", DB.Object<{
+    is_maximum: DB.MemberDecl<DB.Boolean, false>;
+    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>;
+    unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationUnit", {
+        Seconds: DB.EnumCase<null>;
+        Minutes: DB.EnumCase<null>;
+        Hours: DB.EnumCase<null>;
+        Days: DB.EnumCase<null>;
+        Weeks: DB.EnumCase<null>;
+        Months: DB.EnumCase<null>;
+        Years: DB.EnumCase<null>;
+        Centuries: DB.EnumCase<null>;
+        Actions: DB.EnumCase<null>;
+        CombatRounds: DB.EnumCase<null>;
+    }, []>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"CheckResultBasedDurationTranslation", {
+        replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+            full: DB.MemberDecl<DB.String, true>;
+            compressed: DB.MemberDecl<DB.String, true>;
+        }>, []>>, false>;
+    }>, false>;
+}>, []>;
+export declare const IndefiniteDuration: DB.TypeAlias<"IndefiniteDuration", DB.Object<{
+    translations: DB.MemberDecl<DB.NestedEntityMap<"IndefiniteDurationTranslation", {
+        description: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveText", DB.Object<{
+            full: DB.MemberDecl<DB.String, true>;
+            compressed: DB.MemberDecl<DB.String, true>;
+        }>, []>>, true>;
+    }>, true>;
+}>, []>;
+export declare const DurationForSustained: DB.TypeAlias<"DurationForSustained", DB.Object<{
+    maximum: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DurationUnitValue", DB.Object<{
+        value: DB.MemberDecl<DB.Integer, true>;
+        unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationUnit", {
+            Seconds: DB.EnumCase<null>;
+            Minutes: DB.EnumCase<null>;
+            Hours: DB.EnumCase<null>;
+            Days: DB.EnumCase<null>;
+            Weeks: DB.EnumCase<null>;
+            Months: DB.EnumCase<null>;
+            Years: DB.EnumCase<null>;
+            Centuries: DB.EnumCase<null>;
+            Actions: DB.EnumCase<null>;
+            CombatRounds: DB.EnumCase<null>;
+        }, []>>, true>;
+    }>, []>>, true>;
+}>, []>;
+export declare const DurationUnit: DB.Enum<"DurationUnit", {
+    Seconds: DB.EnumCase<null>;
+    Minutes: DB.EnumCase<null>;
+    Hours: DB.EnumCase<null>;
+    Days: DB.EnumCase<null>;
+    Weeks: DB.EnumCase<null>;
+    Months: DB.EnumCase<null>;
+    Years: DB.EnumCase<null>;
+    Centuries: DB.EnumCase<null>;
+    Actions: DB.EnumCase<null>;
+    CombatRounds: DB.EnumCase<null>;
+}, []>;
+export declare const DurationUnitValue: DB.TypeAlias<"DurationUnitValue", DB.Object<{
+    value: DB.MemberDecl<DB.Integer, true>;
+    unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationUnit", {
+        Seconds: DB.EnumCase<null>;
+        Minutes: DB.EnumCase<null>;
+        Hours: DB.EnumCase<null>;
+        Days: DB.EnumCase<null>;
+        Weeks: DB.EnumCase<null>;
+        Months: DB.EnumCase<null>;
+        Years: DB.EnumCase<null>;
+        Centuries: DB.EnumCase<null>;
+        Actions: DB.EnumCase<null>;
+        CombatRounds: DB.EnumCase<null>;
+    }, []>>, true>;
+}>, []>;

package/lib/types/_ActivatableSkillDuration.js

@@ -0,0 +1,138 @@
+import * as DB from "tsondb/schema/dsl";
+import { CheckResultBasedModifier, CheckResultValue } from "./_ActivatableSkillCheckResultBased.js";
+import { ResponsiveText, ResponsiveTextReplace } from "./_ResponsiveText.js";
+import { NestedTranslationMap } from "./Locale.js";
+export const DurationForOneTime = DB.Enum(import.meta.url, {
+    name: "DurationForOneTime",
+    values: () => ({
+        Immediate: DB.EnumCase({ type: DB.IncludeIdentifier(Immediate) }),
+        Permanent: DB.EnumCase({ type: DB.IncludeIdentifier(PermanentDuration) }),
+        Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedDuration) }),
+        CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedDuration) }),
+        Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefiniteDuration) }),
+    }),
+});
+const Immediate = DB.TypeAlias(import.meta.url, {
+    name: "Immediate",
+    type: () => DB.Object({
+        maximum: DB.Optional({
+            comment: "Specified if the duration has a maximum time span.",
+            type: DB.IncludeIdentifier(DurationUnitValue),
+        }),
+        translations: NestedTranslationMap(DB.Optional, "Immediate", DB.Object({
+            replacement: DB.Optional({
+                comment: "A replacement string.",
+                type: DB.IncludeIdentifier(ResponsiveTextReplace),
+            }),
+        })),
+    }),
+});
+const PermanentDuration = DB.TypeAlias(import.meta.url, {
+    name: "PermanentDuration",
+    type: () => DB.Object({
+        translations: NestedTranslationMap(DB.Optional, "PermanentDuration", DB.Object({
+            replacement: DB.Optional({
+                comment: "A replacement string.",
+                type: DB.IncludeIdentifier(ResponsiveTextReplace),
+            }),
+        })),
+    }),
+});
+export const FixedDuration = DB.TypeAlias(import.meta.url, {
+    name: "FixedDuration",
+    type: () => DB.Object({
+        is_maximum: DB.Optional({
+            comment: "If the duration is the maximum duration, so it may end earlier.",
+            type: DB.Boolean(),
+        }),
+        value: DB.Required({
+            comment: "The (unitless) duration.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        unit: DB.Required({
+            comment: "The duration unit.",
+            type: DB.IncludeIdentifier(DurationUnit),
+        }),
+        translations: NestedTranslationMap(DB.Optional, "FixedDuration", DB.Object({
+            replacement: DB.Optional({
+                comment: "A replacement string.",
+                type: DB.IncludeIdentifier(ResponsiveTextReplace),
+            }),
+        }, { minProperties: 1 })),
+    }),
+});
+export const CheckResultBasedDuration = DB.TypeAlias(import.meta.url, {
+    name: "CheckResultBasedDuration",
+    type: () => DB.Object({
+        is_maximum: DB.Optional({
+            comment: "If the duration is the maximum duration, so it may end earlier.",
+            type: DB.Boolean(),
+        }),
+        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),
+        }),
+        unit: DB.Required({
+            comment: "The duration unit.",
+            type: DB.IncludeIdentifier(DurationUnit),
+        }),
+        translations: NestedTranslationMap(DB.Optional, "CheckResultBasedDuration", DB.Object({
+            replacement: DB.Optional({
+                comment: "A replacement string.",
+                type: DB.IncludeIdentifier(ResponsiveTextReplace),
+            }),
+        })),
+    }),
+});
+export const IndefiniteDuration = DB.TypeAlias(import.meta.url, {
+    name: "IndefiniteDuration",
+    type: () => DB.Object({
+        translations: NestedTranslationMap(DB.Required, "IndefiniteDuration", DB.Object({
+            description: DB.Required({
+                comment: "A description of the duration.",
+                type: DB.IncludeIdentifier(ResponsiveText),
+            }),
+        })),
+    }),
+});
+export const DurationForSustained = DB.TypeAlias(import.meta.url, {
+    name: "DurationForSustained",
+    type: () => DB.Object({
+        maximum: DB.Required({
+            comment: "The sustained skill can be active a maximum amount of time.",
+            type: DB.IncludeIdentifier(DurationUnitValue),
+        }),
+    }),
+});
+export const DurationUnit = DB.Enum(import.meta.url, {
+    name: "DurationUnit",
+    values: () => ({
+        Seconds: DB.EnumCase({ type: null }),
+        Minutes: DB.EnumCase({ type: null }),
+        Hours: DB.EnumCase({ type: null }),
+        Days: DB.EnumCase({ type: null }),
+        Weeks: DB.EnumCase({ type: null }),
+        Months: DB.EnumCase({ type: null }),
+        Years: DB.EnumCase({ type: null }),
+        Centuries: DB.EnumCase({ type: null }),
+        Actions: DB.EnumCase({ type: null }),
+        CombatRounds: DB.EnumCase({ type: null }),
+    }),
+});
+export const DurationUnitValue = DB.TypeAlias(import.meta.url, {
+    name: "DurationUnitValue",
+    type: () => DB.Object({
+        value: DB.Required({
+            comment: "The (unitless) duration value.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        unit: DB.Required({
+            comment: "The unit of the `value`.",
+            type: DB.IncludeIdentifier(DurationUnit),
+        }),
+    }),
+});

package/lib/types/_ActivatableSkillEffect.d.ts

@@ -0,0 +1,16 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const ActivatableSkillEffect: DB.Enum<"ActivatableSkillEffect", {
+    Plain: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ActivatableSkillPlainEffect", DB.Object<{
+        text: DB.MemberDecl<DB.String, true>;
+    }>, []>>>;
+    ForEachQualityLevel: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ActivatableSkillEffectForEachQualityLevel", DB.Object<{
+        text_before: DB.MemberDecl<DB.String, true>;
+        quality_levels: DB.MemberDecl<DB.Array<DB.String>, true>;
+        text_after: DB.MemberDecl<DB.String, false>;
+    }>, []>>>;
+    ForEachTwoQualityLevels: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ActivatableSkillEffectForEachTwoQualityLevels", DB.Object<{
+        text_before: DB.MemberDecl<DB.String, true>;
+        quality_levels: DB.MemberDecl<DB.Array<DB.String>, true>;
+        text_after: DB.MemberDecl<DB.String, false>;
+    }>, []>>>;
+}, []>;

package/lib/types/_ActivatableSkillEffect.js

@@ -0,0 +1,65 @@
+import * as DB from "tsondb/schema/dsl";
+export const ActivatableSkillEffect = DB.Enum(import.meta.url, {
+    name: "ActivatableSkillEffect",
+    comment: "The effect description may be either a plain text or a text that is divided by a list of effects for each quality level. It may also be a list for each two quality levels.",
+    values: () => ({
+        Plain: DB.EnumCase({
+            type: DB.IncludeIdentifier(ActivatableSkillPlainEffect),
+        }),
+        ForEachQualityLevel: DB.EnumCase({
+            type: DB.IncludeIdentifier(ActivatableSkillEffectForEachQualityLevel),
+        }),
+        ForEachTwoQualityLevels: DB.EnumCase({
+            type: DB.IncludeIdentifier(ActivatableSkillEffectForEachTwoQualityLevels),
+        }),
+    }),
+});
+const ActivatableSkillPlainEffect = DB.TypeAlias(import.meta.url, {
+    name: "ActivatableSkillPlainEffect",
+    type: () => DB.Object({
+        text: DB.Required({
+            comment: "The effect description.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+        }),
+    }),
+});
+const ActivatableSkillEffectForEachQualityLevel = DB.TypeAlias(import.meta.url, {
+    name: "ActivatableSkillEffectForEachQualityLevel",
+    type: () => DB.Object({
+        text_before: DB.Required({
+            comment: "The effect description before the list of effects for each quality level.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+        }),
+        quality_levels: DB.Required({
+            comment: "The list of effects for each quality level. The first element represents QL 1, the second element QL 2, and so on.",
+            type: DB.Array(DB.String({ minLength: 1, markdown: "block" }), {
+                minItems: 6,
+                maxItems: 6,
+            }),
+        }),
+        text_after: DB.Optional({
+            comment: "The effect description after the list of effects for each quality level.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+        }),
+    }),
+});
+const ActivatableSkillEffectForEachTwoQualityLevels = DB.TypeAlias(import.meta.url, {
+    name: "ActivatableSkillEffectForEachTwoQualityLevels",
+    type: () => DB.Object({
+        text_before: DB.Required({
+            comment: "The effect description before the list of effects for each quality level.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+        }),
+        quality_levels: DB.Required({
+            comment: "The list of effects for each two quality levels. The first element represents QL 1–2, the second element QL 3–4 and the third element QL 5–6.",
+            type: DB.Array(DB.String({ minLength: 1, markdown: "block" }), {
+                minItems: 3,
+                maxItems: 3,
+            }),
+        }),
+        text_after: DB.Optional({
+            comment: "The effect description after the list of effects for each quality level.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+        }),
+    }),
+});

package/lib/types/_ActivatableSkillRange.d.ts

@@ -0,0 +1,62 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const Range: DB.TypeAlias<"Range", DB.Object<{
+    value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RangeValue", {
+        Modifiable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ModifiableRange", DB.Object<{
+            is_maximum: DB.MemberDecl<DB.Boolean, false>;
+            initial_modification_level: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            is_radius: DB.MemberDecl<DB.Boolean, false>;
+        }>, []>>>;
+        Sight: DB.EnumCase<null>;
+        Self: DB.EnumCase<null>;
+        Global: DB.EnumCase<null>;
+        Touch: DB.EnumCase<null>;
+        Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedRange", DB.Object<{
+            is_maximum: DB.MemberDecl<DB.Boolean, false>;
+            value: DB.MemberDecl<DB.Integer, true>;
+            unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RangeUnit", {
+                Steps: DB.EnumCase<null>;
+                Miles: DB.EnumCase<null>;
+            }, []>>, true>;
+            is_radius: DB.MemberDecl<DB.Boolean, false>;
+        }>, []>>>;
+        CheckResultBased: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedRange", DB.Object<{
+            is_maximum: DB.MemberDecl<DB.Boolean, false>;
+            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>;
+            unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RangeUnit", {
+                Steps: DB.EnumCase<null>;
+                Miles: DB.EnumCase<null>;
+            }, []>>, true>;
+            is_radius: DB.MemberDecl<DB.Boolean, false>;
+        }>, []>>>;
+    }, []>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"RangeTranslation", {
+        note: 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<"ResponsiveTextReplace", DB.Object<{
+            full: DB.MemberDecl<DB.String, true>;
+            compressed: DB.MemberDecl<DB.String, true>;
+        }>, []>>, false>;
+    }>, false>;
+}>, []>;
+export declare const FixedRange: DB.TypeAlias<"FixedRange", DB.Object<{
+    is_maximum: DB.MemberDecl<DB.Boolean, false>;
+    value: DB.MemberDecl<DB.Integer, true>;
+    unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RangeUnit", {
+        Steps: DB.EnumCase<null>;
+        Miles: DB.EnumCase<null>;
+    }, []>>, true>;
+    is_radius: DB.MemberDecl<DB.Boolean, false>;
+}>, []>;

package/lib/types/_ActivatableSkillRange.js

@@ -0,0 +1,106 @@
+import * as DB from "tsondb/schema/dsl";
+import { CheckResultBasedModifier, CheckResultValue } from "./_ActivatableSkillCheckResultBased.js";
+import { SkillModificationLevelIdentifier } from "./_Identifier.js";
+import { ResponsiveTextOptional, ResponsiveTextReplace } from "./_ResponsiveText.js";
+import { NestedTranslationMap } from "./Locale.js";
+export const Range = DB.TypeAlias(import.meta.url, {
+    name: "Range",
+    type: () => DB.Object({
+        value: DB.Required({
+            comment: "The range value.",
+            type: DB.IncludeIdentifier(RangeValue),
+        }),
+        translations: NestedTranslationMap(DB.Optional, "Range", DB.Object({
+            note: DB.Optional({
+                comment: "A note, appended to the generated string in parenthesis. If the generated is modified using `replacement`, the note is appended to the modifier string.",
+                type: DB.IncludeIdentifier(ResponsiveTextOptional),
+            }),
+            replacement: DB.Optional({
+                comment: "A replacement string. If `note` is provided, it is appended to the replaced string.",
+                type: DB.IncludeIdentifier(ResponsiveTextReplace),
+            }),
+        }, { minProperties: 1 })),
+    }),
+});
+const RangeValue = DB.Enum(import.meta.url, {
+    name: "RangeValue",
+    values: () => ({
+        Modifiable: DB.EnumCase({ type: DB.IncludeIdentifier(ModifiableRange) }),
+        Sight: DB.EnumCase({ type: null }),
+        Self: DB.EnumCase({ type: null }),
+        Global: DB.EnumCase({ comment: "German: *dereumfassend*", type: null }),
+        Touch: DB.EnumCase({ type: null }),
+        Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedRange) }),
+        CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedRange) }),
+    }),
+});
+const ModifiableRange = DB.TypeAlias(import.meta.url, {
+    name: "ModifiableRange",
+    type: () => DB.Object({
+        is_maximum: DB.Optional({
+            comment: "If `true`, the range is a maximum range.",
+            type: DB.Boolean(),
+        }),
+        initial_modification_level: DB.Required({
+            comment: "The initial skill modification identifier/level.",
+            type: SkillModificationLevelIdentifier(),
+        }),
+        is_radius: DB.Optional({
+            comment: "If `true`, the range is a radius.",
+            type: DB.Boolean(),
+        }),
+    }),
+});
+export const FixedRange = DB.TypeAlias(import.meta.url, {
+    name: "FixedRange",
+    type: () => DB.Object({
+        is_maximum: DB.Optional({
+            comment: "If `true`, the range is a maximum range.",
+            type: DB.Boolean(),
+        }),
+        value: DB.Required({
+            comment: "The (unitless) range value.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        unit: DB.Required({
+            comment: "The unit of the `value`.",
+            type: DB.IncludeIdentifier(RangeUnit),
+        }),
+        is_radius: DB.Optional({
+            comment: "If `true`, the range is a radius.",
+            type: DB.Boolean(),
+        }),
+    }),
+});
+const CheckResultBasedRange = DB.TypeAlias(import.meta.url, {
+    name: "CheckResultBasedRange",
+    type: () => DB.Object({
+        is_maximum: DB.Optional({
+            comment: "If the range is the maximum range.",
+            type: DB.Boolean(),
+        }),
+        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),
+        }),
+        unit: DB.Required({
+            comment: "The duration unit.",
+            type: DB.IncludeIdentifier(RangeUnit),
+        }),
+        is_radius: DB.Optional({
+            comment: "If `true`, the range is a radius.",
+            type: DB.Boolean(),
+        }),
+    }),
+});
+const RangeUnit = DB.Enum(import.meta.url, {
+    name: "RangeUnit",
+    values: () => ({
+        Steps: DB.EnumCase({ type: null }),
+        Miles: DB.EnumCase({ type: null }),
+    }),
+});

package/lib/types/_ActivatableSkillTargetCategory.d.ts

@@ -0,0 +1,14 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const AffectedTargetCategories: DB.TypeAlias<"AffectedTargetCategories", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SpecificAffectedTargetCategory", DB.Object<{
+    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecificAffectedTargetCategoryIdentifier", {
+        Self: DB.EnumCase<null>;
+        Zone: DB.EnumCase<null>;
+        LiturgicalChantsAndCeremonies: DB.EnumCase<null>;
+        Cantrips: DB.EnumCase<null>;
+        Spellworks: DB.EnumCase<null>;
+        Predefined: DB.EnumCase<DB.ReferenceIdentifier>;
+    }, []>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"SpecificAffectedTargetCategoryTranslation", {
+        note: DB.MemberDecl<DB.String, true>;
+    }>, false>;
+}>, []>>>, []>;

package/lib/types/_ActivatableSkillTargetCategory.js

@@ -0,0 +1,30 @@
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "./Locale.js";
+import { TargetCategoryIdentifier } from "./_Identifier.js";
+export const AffectedTargetCategories = DB.TypeAlias(import.meta.url, {
+    name: "AffectedTargetCategories",
+    comment: `The target category – the kind of creature or object – the skill affects.
+
+If no target categories are given, the skill applies to all target categories.`,
+    type: () => DB.Array(DB.IncludeIdentifier(SpecificAffectedTargetCategory)),
+});
+const SpecificAffectedTargetCategory = DB.TypeAlias(import.meta.url, {
+    name: "SpecificAffectedTargetCategory",
+    type: () => DB.Object({
+        id: DB.Required({ type: DB.IncludeIdentifier(SpecificAffectedTargetCategoryIdentifier) }),
+        translations: NestedTranslationMap(DB.Optional, "SpecificAffectedTargetCategory", DB.Object({
+            note: DB.Required({ type: DB.String({ minLength: 1 }) }),
+        })),
+    }),
+});
+const SpecificAffectedTargetCategoryIdentifier = DB.Enum(import.meta.url, {
+    name: "SpecificAffectedTargetCategoryIdentifier",
+    values: () => ({
+        Self: DB.EnumCase({ type: null }),
+        Zone: DB.EnumCase({ type: null }),
+        LiturgicalChantsAndCeremonies: DB.EnumCase({ type: null }),
+        Cantrips: DB.EnumCase({ type: null }),
+        Spellworks: DB.EnumCase({ type: null }),
+        Predefined: DB.EnumCase({ type: TargetCategoryIdentifier() }),
+    }),
+});

package/lib/types/_AlternativeNames.d.ts

@@ -0,0 +1,5 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const AlternativeName: DB.TypeAlias<"AlternativeName", DB.Object<{
+    name: DB.MemberDecl<DB.String, true>;
+    region: DB.MemberDecl<DB.String, false>;
+}>, []>;

package/lib/types/_AlternativeNames.js

@@ -0,0 +1,14 @@
+import * as DB from "tsondb/schema/dsl";
+export const AlternativeName = DB.TypeAlias(import.meta.url, {
+    name: "AlternativeName",
+    type: () => DB.Object({
+        name: DB.Required({
+            comment: "An alternative name of the disease.",
+            type: DB.String({ minLength: 1 }),
+        }),
+        region: DB.Optional({
+            comment: "The region where this alternative name is used.",
+            type: DB.String({ minLength: 1 }),
+        }),
+    }),
+});