optolith-database-schema 0.17.2 → 0.18.2

package/lib/types/_ActivatableSkillDuration.js

@@ -1 +1,138 @@
-export {};
+import { Boolean, Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional, Required, TypeAlias, } from "tsondb/schema/def";
+import { CheckResultBasedModifier, CheckResultValue } from "./_ActivatableSkillCheckResultBased.js";
+import { ResponsiveText, ResponsiveTextReplace } from "./_ResponsiveText.js";
+import { NestedLocaleMap } from "./Locale.js";
+export const DurationForOneTime = Enum(import.meta.url, {
+    name: "DurationForOneTime",
+    values: () => ({
+        Immediate: EnumCase({ type: IncludeIdentifier(Immediate) }),
+        Permanent: EnumCase({ type: IncludeIdentifier(PermanentDuration) }),
+        Fixed: EnumCase({ type: IncludeIdentifier(FixedDuration) }),
+        CheckResultBased: EnumCase({ type: IncludeIdentifier(CheckResultBasedDuration) }),
+        Indefinite: EnumCase({ type: IncludeIdentifier(IndefiniteDuration) }),
+    }),
+});
+const Immediate = TypeAlias(import.meta.url, {
+    name: "Immediate",
+    type: () => Object({
+        maximum: Optional({
+            comment: "Specified if the duration has a maximum time span.",
+            type: IncludeIdentifier(DurationUnitValue),
+        }),
+        translations: NestedLocaleMap(Optional, "ImmediateTranslation", Object({
+            replacement: Optional({
+                comment: "A replacement string.",
+                type: IncludeIdentifier(ResponsiveTextReplace),
+            }),
+        })),
+    }),
+});
+const PermanentDuration = TypeAlias(import.meta.url, {
+    name: "PermanentDuration",
+    type: () => Object({
+        translations: NestedLocaleMap(Optional, "PermanentDurationTranslation", Object({
+            replacement: Optional({
+                comment: "A replacement string.",
+                type: IncludeIdentifier(ResponsiveTextReplace),
+            }),
+        })),
+    }),
+});
+export const FixedDuration = TypeAlias(import.meta.url, {
+    name: "FixedDuration",
+    type: () => Object({
+        is_maximum: Optional({
+            comment: "If the duration is the maximum duration, so it may end earlier.",
+            type: Boolean(),
+        }),
+        value: Required({
+            comment: "The (unitless) duration.",
+            type: Integer({ minimum: 1 }),
+        }),
+        unit: Required({
+            comment: "The duration unit.",
+            type: IncludeIdentifier(DurationUnit),
+        }),
+        translations: NestedLocaleMap(Optional, "FixedDurationTranslation", Object({
+            replacement: Optional({
+                comment: "A replacement string.",
+                type: IncludeIdentifier(ResponsiveTextReplace),
+            }),
+        }, { minProperties: 1 })),
+    }),
+});
+export const CheckResultBasedDuration = TypeAlias(import.meta.url, {
+    name: "CheckResultBasedDuration",
+    type: () => Object({
+        is_maximum: Optional({
+            comment: "If the duration is the maximum duration, so it may end earlier.",
+            type: Boolean(),
+        }),
+        base: Required({
+            comment: "The base value that is derived from the check result.",
+            type: IncludeIdentifier(CheckResultValue),
+        }),
+        modifier: Optional({
+            comment: "If defined, it modifies the base value.",
+            type: IncludeIdentifier(CheckResultBasedModifier),
+        }),
+        unit: Required({
+            comment: "The duration unit.",
+            type: IncludeIdentifier(DurationUnit),
+        }),
+        translations: NestedLocaleMap(Optional, "CheckResultBasedDurationTranslation", Object({
+            replacement: Optional({
+                comment: "A replacement string.",
+                type: IncludeIdentifier(ResponsiveTextReplace),
+            }),
+        })),
+    }),
+});
+export const IndefiniteDuration = TypeAlias(import.meta.url, {
+    name: "IndefiniteDuration",
+    type: () => Object({
+        translations: NestedLocaleMap(Required, "IndefiniteDurationTranslation", Object({
+            description: Required({
+                comment: "A description of the duration.",
+                type: IncludeIdentifier(ResponsiveText),
+            }),
+        })),
+    }),
+});
+export const DurationForSustained = TypeAlias(import.meta.url, {
+    name: "DurationForSustained",
+    type: () => Object({
+        maximum: Required({
+            comment: "The sustained skill can be active a maximum amount of time.",
+            type: IncludeIdentifier(DurationUnitValue),
+        }),
+    }),
+});
+export const DurationUnit = Enum(import.meta.url, {
+    name: "DurationUnit",
+    values: () => ({
+        Seconds: EnumCase({ type: null }),
+        Minutes: EnumCase({ type: null }),
+        Hours: EnumCase({ type: null }),
+        Days: EnumCase({ type: null }),
+        Weeks: EnumCase({ type: null }),
+        Months: EnumCase({ type: null }),
+        Years: EnumCase({ type: null }),
+        Centuries: EnumCase({ type: null }),
+        Actions: EnumCase({ type: null }),
+        CombatRounds: EnumCase({ type: null }),
+    }),
+});
+export const DurationUnitValue = TypeAlias(import.meta.url, {
+    name: "DurationUnitValue",
+    type: () => Object({
+        value: Required({
+            comment: "The (unitless) duration value.",
+            type: Integer({ minimum: 1 }),
+        }),
+        unit: Required({
+            comment: "The unit of the `value`.",
+            type: IncludeIdentifier(DurationUnit),
+        }),
+    }),
+});

package/lib/types/_ActivatableSkillEffect.d.ts

@@ -1,68 +1,16 @@
-import { NonEmptyMarkdown } from "./_NonEmptyString.js";
-/**
- * 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.
- */
-export type Effect = {
-    tag: "Plain";
-    plain: PlainEffect;
-} | {
-    tag: "ForEachQualityLevel";
-    for_each_quality_level: EffectForEachQualityLevel;
-} | {
-    tag: "ForEachTwoQualityLevels";
-    for_each_two_quality_levels: EffectForEachTwoQualityLevels;
-};
-export type PlainEffect = {
-    /**
-     * The effect description.
-     */
-    text: NonEmptyMarkdown;
-};
-export type EffectForEachQualityLevel = {
-    /**
-     * The effect description before the list of effects for each quality
-     * level.
-     */
-    text_before: NonEmptyMarkdown;
-    /**
-     * The list of effects for each quality level. The first element
-     * represents QL 1, the second element QL 2, and so on.
-     */
-    quality_levels: [
-        NonEmptyMarkdown,
-        NonEmptyMarkdown,
-        NonEmptyMarkdown,
-        NonEmptyMarkdown,
-        NonEmptyMarkdown,
-        NonEmptyMarkdown
-    ];
-    /**
-     * The effect description after the list of effects for each quality
-     * level.
-     */
-    text_after?: NonEmptyMarkdown;
-};
-export type EffectForEachTwoQualityLevels = {
-    /**
-     * The effect description before the list of effects for each quality
-     * level.
-     */
-    text_before: NonEmptyMarkdown;
-    /**
-     * 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.
-     */
-    quality_levels: [
-        NonEmptyMarkdown,
-        NonEmptyMarkdown,
-        NonEmptyMarkdown
-    ];
-    /**
-     * The effect description after the list of effects for each quality
-     * level.
-     */
-    text_after?: NonEmptyMarkdown;
-};
+import { Array, Enum, EnumCase, IncludeIdentifier, Object, String, TypeAlias } from "tsondb/schema/def";
+export declare const ActivatableSkillEffect: Enum<"ActivatableSkillEffect", {
+    Plain: EnumCase<IncludeIdentifier<[], TypeAlias<"ActivatableSkillPlainEffect", Object<{
+        text: import("tsondb/schema/def").MemberDecl<String, true>;
+    }>, []>>>;
+    ForEachQualityLevel: EnumCase<IncludeIdentifier<[], TypeAlias<"ActivatableSkillEffectForEachQualityLevel", Object<{
+        text_before: import("tsondb/schema/def").MemberDecl<String, true>;
+        quality_levels: import("tsondb/schema/def").MemberDecl<Array<String>, true>;
+        text_after: import("tsondb/schema/def").MemberDecl<String, false>;
+    }>, []>>>;
+    ForEachTwoQualityLevels: EnumCase<IncludeIdentifier<[], TypeAlias<"ActivatableSkillEffectForEachTwoQualityLevels", Object<{
+        text_before: import("tsondb/schema/def").MemberDecl<String, true>;
+        quality_levels: import("tsondb/schema/def").MemberDecl<Array<String>, true>;
+        text_after: import("tsondb/schema/def").MemberDecl<String, false>;
+    }>, []>>>;
+}, []>;

package/lib/types/_ActivatableSkillEffect.js

@@ -1 +1,65 @@
-export {};
+import { Array, Enum, EnumCase, IncludeIdentifier, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
+export const ActivatableSkillEffect = 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: EnumCase({
+            type: IncludeIdentifier(ActivatableSkillPlainEffect),
+        }),
+        ForEachQualityLevel: EnumCase({
+            type: IncludeIdentifier(ActivatableSkillEffectForEachQualityLevel),
+        }),
+        ForEachTwoQualityLevels: EnumCase({
+            type: IncludeIdentifier(ActivatableSkillEffectForEachTwoQualityLevels),
+        }),
+    }),
+});
+const ActivatableSkillPlainEffect = TypeAlias(import.meta.url, {
+    name: "ActivatableSkillPlainEffect",
+    type: () => Object({
+        text: Required({
+            comment: "The effect description.",
+            type: String({ minLength: 1, isMarkdown: true }),
+        }),
+    }),
+});
+const ActivatableSkillEffectForEachQualityLevel = TypeAlias(import.meta.url, {
+    name: "ActivatableSkillEffectForEachQualityLevel",
+    type: () => Object({
+        text_before: Required({
+            comment: "The effect description before the list of effects for each quality level.",
+            type: String({ minLength: 1, isMarkdown: true }),
+        }),
+        quality_levels: 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: Array(String({ minLength: 1, isMarkdown: true }), {
+                minItems: 6,
+                maxItems: 6,
+            }),
+        }),
+        text_after: Optional({
+            comment: "The effect description after the list of effects for each quality level.",
+            type: String({ minLength: 1, isMarkdown: true }),
+        }),
+    }),
+});
+const ActivatableSkillEffectForEachTwoQualityLevels = TypeAlias(import.meta.url, {
+    name: "ActivatableSkillEffectForEachTwoQualityLevels",
+    type: () => Object({
+        text_before: Required({
+            comment: "The effect description before the list of effects for each quality level.",
+            type: String({ minLength: 1, isMarkdown: true }),
+        }),
+        quality_levels: 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: Array(String({ minLength: 1, isMarkdown: true }), {
+                minItems: 3,
+                maxItems: 3,
+            }),
+        }),
+        text_after: Optional({
+            comment: "The effect description after the list of effects for each quality level.",
+            type: String({ minLength: 1, isMarkdown: true }),
+        }),
+    }),
+});

package/lib/types/_ActivatableSkillRange.d.ts

@@ -1,115 +1,61 @@
-import { CheckResultBasedModifier, CheckResultValue } from "./_ActivatableSkillCheckResultBased.js";
-import { LocaleMap } from "./_LocaleMap.js";
-import { ResponsiveTextOptional, ResponsiveTextReplace } from "./_ResponsiveText.js";
-export type Range = {
-    value: RangeValue;
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations?: LocaleMap<RangeTranslation>;
-};
-export type RangeValue = {
-    tag: "Modifiable";
-    modifiable: ModifiableRange;
-} | {
-    tag: "Sight";
-    sight: {};
-} | {
-    tag: "Self";
-    self: {};
-}
-/**
- * German: *dereumfassend*
- */
- | {
-    tag: "Global";
-    global: {};
-} | {
-    tag: "Touch";
-    touch: {};
-} | {
-    tag: "Fixed";
-    fixed: FixedRange;
-} | {
-    tag: "CheckResultBased";
-    check_result_based: CheckResultBasedRange;
-};
-export type ModifiableRange = {
-    /**
-     * If `true`, the range is a maximum range.
-     */
-    is_maximum?: true;
-    /**
-     * The initial skill modification identifier/level.
-     * @integer
-     * @minimum 1
-     * @maximum 6
-     */
-    initial_modification_level: number;
-    /**
-     * If `true`, the range is a radius.
-     */
-    is_radius?: true;
-};
-export type FixedRange = {
-    /**
-     * If `true`, the range is a maximum range.
-     */
-    is_maximum?: true;
-    /**
-     * The (unitless) range value.
-     * @integer
-     * @minimum 1
-     */
-    value: number;
-    /**
-     * The unit of the `value`.
-     */
-    unit: RangeUnit;
-    /**
-     * If `true`, the range is a radius.
-     */
-    is_radius?: true;
-};
-/**
- * Defines the range being based on a check result.
- */
-export type CheckResultBasedRange = {
-    /**
-     * If the range is the maximum range.
-     */
-    is_maximum?: true;
-    /**
-     * The base value that is derived from the check result.
-     */
-    base: CheckResultValue;
-    /**
-     * If defined, it modifies the base value.
-     */
-    modifier?: CheckResultBasedModifier;
-    /**
-     * The duration unit.
-     */
-    unit: RangeUnit;
-    /**
-     * If `true`, the range is a radius.
-     */
-    is_radius?: true;
-};
-/**
- * @minProperties 1
- */
-export type RangeTranslation = {
-    /**
-     * A note, appended to the generated string in parenthesis. If the
-     * generated is modified using `replacement`, the note is appended to
-     * the modifier string.
-     */
-    note?: ResponsiveTextOptional;
-    /**
-     * A replacement string. If `note` is provided, it is appended to the
-     * replaced string.
-     */
-    replacement?: ResponsiveTextReplace;
-};
-export type RangeUnit = "Steps" | "Miles";
+import { Boolean, Enum, EnumCase, IncludeIdentifier, Integer, Object, TypeAlias } from "tsondb/schema/def";
+export declare const Range: TypeAlias<"Range", Object<{
+    value: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"RangeValue", {
+        Modifiable: EnumCase<IncludeIdentifier<[], TypeAlias<"ModifiableRange", Object<{
+            is_maximum: import("tsondb/schema/def").MemberDecl<Boolean, false>;
+            initial_modification_level: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+            is_radius: import("tsondb/schema/def").MemberDecl<Boolean, false>;
+        }>, []>>>;
+        Sight: EnumCase<null>;
+        Self: EnumCase<null>;
+        Global: EnumCase<null>;
+        Touch: EnumCase<null>;
+        Fixed: EnumCase<IncludeIdentifier<[], TypeAlias<"FixedRange", Object<{
+            is_maximum: import("tsondb/schema/def").MemberDecl<Boolean, false>;
+            value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+            unit: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"RangeUnit", {
+                Steps: EnumCase<null>;
+                Miles: EnumCase<null>;
+            }, []>>, true>;
+            is_radius: import("tsondb/schema/def").MemberDecl<Boolean, false>;
+        }>, []>>>;
+        CheckResultBased: EnumCase<IncludeIdentifier<[], TypeAlias<"CheckResultBasedRange", Object<{
+            is_maximum: import("tsondb/schema/def").MemberDecl<Boolean, false>;
+            base: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"CheckResultValue", {
+                QualityLevels: EnumCase<null>;
+                SkillPoints: EnumCase<null>;
+            }, []>>, true>;
+            modifier: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"CheckResultBasedModifier", Object<{
+                arithmetic: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"CheckResultArithmetic", {
+                    Multiply: EnumCase<null>;
+                    Divide: EnumCase<null>;
+                }, []>>, true>;
+                value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+            }>, []>>, false>;
+            unit: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"RangeUnit", {
+                Steps: EnumCase<null>;
+                Miles: EnumCase<null>;
+            }, []>>, true>;
+            is_radius: import("tsondb/schema/def").MemberDecl<Boolean, false>;
+        }>, []>>>;
+    }, []>>, true>;
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"RangeTranslation", {
+        note: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ResponsiveTextOptional", Object<{
+            full: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
+            compressed: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, false>;
+        }>, []>>, false>;
+        replacement: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ResponsiveTextReplace", Object<{
+            full: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
+            compressed: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
+        }>, []>>, false>;
+    }>, false>;
+}>, []>;
+export declare const FixedRange: TypeAlias<"FixedRange", Object<{
+    is_maximum: import("tsondb/schema/def").MemberDecl<Boolean, false>;
+    value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+    unit: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"RangeUnit", {
+        Steps: EnumCase<null>;
+        Miles: EnumCase<null>;
+    }, []>>, true>;
+    is_radius: import("tsondb/schema/def").MemberDecl<Boolean, false>;
+}>, []>;

package/lib/types/_ActivatableSkillRange.js

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

package/lib/types/_ActivatableSkillTargetCategory.d.ts

@@ -1,39 +1,13 @@
-import { LocaleMap } from "./_LocaleMap.js";
-import { NonEmptyString } from "./_NonEmptyString.js";
-import { TargetCategoryReference } from "./_SimpleReferences.js";
-/**
- * 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.
- */
-export type TargetCategory = SpecificTargetCategory[];
-export type SpecificTargetCategory = {
-    id: TargetCategoryIdentifier;
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations?: LocaleMap<SpecificTargetCategoryTranslation>;
-};
-export type SpecificTargetCategoryTranslation = {
-    /**
-     * A note, appended to the generated string in parenthesis.
-     */
-    note: NonEmptyString;
-};
-export type TargetCategoryIdentifier = {
-    tag: "Self";
-    self: {};
-} | {
-    tag: "Zone";
-    zone: {};
-} | {
-    tag: "LiturgicalChantsAndCeremonies";
-    liturgical_chants_and_ceremonies: {};
-} | {
-    tag: "Cantrips";
-    cantrips: {};
-} | {
-    tag: "Predefined";
-    predefined: TargetCategoryReference;
-};
+import { Array, Enum, EnumCase, IncludeIdentifier, Object, String, TypeAlias } from "tsondb/schema/def";
+export declare const AffectedTargetCategories: TypeAlias<"AffectedTargetCategories", Array<IncludeIdentifier<[], TypeAlias<"SpecificAffectedTargetCategory", Object<{
+    id: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"SpecificAffectedTargetCategoryIdentifier", {
+        Self: EnumCase<null>;
+        Zone: EnumCase<null>;
+        LiturgicalChantsAndCeremonies: EnumCase<null>;
+        Cantrips: EnumCase<null>;
+        Predefined: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+    }, []>>, true>;
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"SpecificAffectedTargetCategoryTranslation", {
+        note: import("tsondb/schema/def").MemberDecl<String, true>;
+    }>, false>;
+}>, []>>>, []>;

package/lib/types/_ActivatableSkillTargetCategory.js

@@ -1 +1,29 @@
-export {};
+import { Array, Enum, EnumCase, IncludeIdentifier, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
+import { NestedLocaleMap } from "./Locale.js";
+import { TargetCategoryIdentifier } from "./_Identifier.js";
+export const AffectedTargetCategories = 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: () => Array(IncludeIdentifier(SpecificAffectedTargetCategory)),
+});
+const SpecificAffectedTargetCategory = TypeAlias(import.meta.url, {
+    name: "SpecificAffectedTargetCategory",
+    type: () => Object({
+        id: Required({ type: IncludeIdentifier(SpecificAffectedTargetCategoryIdentifier) }),
+        translations: NestedLocaleMap(Optional, "SpecificAffectedTargetCategoryTranslation", Object({
+            note: Required({ type: String({ minLength: 1 }) }),
+        })),
+    }),
+});
+const SpecificAffectedTargetCategoryIdentifier = Enum(import.meta.url, {
+    name: "SpecificAffectedTargetCategoryIdentifier",
+    values: () => ({
+        Self: EnumCase({ type: null }),
+        Zone: EnumCase({ type: null }),
+        LiturgicalChantsAndCeremonies: EnumCase({ type: null }),
+        Cantrips: EnumCase({ type: null }),
+        Predefined: EnumCase({ type: TargetCategoryIdentifier() }),
+    }),
+});