optolith-database-schema 0.17.0 → 0.18.1

package/lib/types/_ActivatableSkill.js

@@ -1,4 +1,85 @@
 /**
  * @title Activatable Skill
  */
-export {};
+import { Enum, EnumCase, GenIncludeIdentifier, GenTypeAlias, IncludeIdentifier, Object, Optional, Param, Required, String, TypeAlias, TypeArgument, } from "tsondb/schema/def";
+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 = GenTypeAlias(import.meta.url, {
+    name: "OneTimePerformanceParameters",
+    parameters: [Param("CastingTime")],
+    type: CastingTime => Object({
+        casting_time: Required({
+            type: TypeArgument(CastingTime),
+        }),
+        cost: Required({
+            type: IncludeIdentifier(OneTimeCost),
+        }),
+        range: Required({
+            type: IncludeIdentifier(Range),
+        }),
+        duration: Required({
+            type: IncludeIdentifier(DurationForOneTime),
+        }),
+    }),
+});
+const SustainedPerformanceParameters = GenTypeAlias(import.meta.url, {
+    name: "SustainedPerformanceParameters",
+    parameters: [Param("CastingTime")],
+    type: CastingTime => Object({
+        casting_time: Required({
+            type: TypeArgument(CastingTime),
+        }),
+        cost: Required({
+            type: IncludeIdentifier(SustainedCost),
+        }),
+        range: Required({
+            type: IncludeIdentifier(Range),
+        }),
+        duration: Optional({
+            type: IncludeIdentifier(DurationForSustained),
+        }),
+    }),
+});
+export const FastPerformanceParameters = Enum(import.meta.url, {
+    name: "FastPerformanceParameters",
+    values: () => ({
+        OneTime: EnumCase({ type: IncludeIdentifier(FastOneTimePerformanceParameters) }),
+        Sustained: EnumCase({ type: IncludeIdentifier(FastSustainedPerformanceParameters) }),
+    }),
+});
+const FastOneTimePerformanceParameters = TypeAlias(import.meta.url, {
+    name: "FastOneTimePerformanceParameters",
+    type: () => GenIncludeIdentifier(OneTimePerformanceParameters, [IncludeIdentifier(FastCastingTime)]),
+});
+const FastSustainedPerformanceParameters = TypeAlias(import.meta.url, {
+    name: "FastSustainedPerformanceParameters",
+    type: () => GenIncludeIdentifier(SustainedPerformanceParameters, [IncludeIdentifier(FastCastingTime)]),
+});
+export const SlowPerformanceParameters = Enum(import.meta.url, {
+    name: "SlowPerformanceParameters",
+    values: () => ({
+        OneTime: EnumCase({ type: IncludeIdentifier(SlowOneTimePerformanceParameters) }),
+        Sustained: EnumCase({ type: IncludeIdentifier(SlowSustainedPerformanceParameters) }),
+    }),
+});
+const SlowOneTimePerformanceParameters = TypeAlias(import.meta.url, {
+    name: "SlowOneTimePerformanceParameters",
+    type: () => GenIncludeIdentifier(OneTimePerformanceParameters, [IncludeIdentifier(SlowCastingTime)]),
+});
+const SlowSustainedPerformanceParameters = TypeAlias(import.meta.url, {
+    name: "SlowSustainedPerformanceParameters",
+    type: () => GenIncludeIdentifier(SustainedPerformanceParameters, [IncludeIdentifier(SlowCastingTime)]),
+});
+export const OldParameter = TypeAlias(import.meta.url, {
+    name: "OldParameter",
+    type: () => Object({
+        full: Required({
+            type: String(),
+        }),
+        abbr: Required({
+            type: String(),
+        }),
+    }),
+});

package/lib/types/_ActivatableSkillCastingTime.d.ts

@@ -1,74 +1,66 @@
-import { SlowSkillCastingTimeUnit } from "./SkillModificationLevel.js";
-export type CastingTime<NonModifiable extends Object> = {
-    tag: "Modifiable";
-    modifiable: ModifiableCastingTime;
-} | {
-    tag: "NonModifiable";
-    non_modifiable: NonModifiable;
-};
-export type ModifiableCastingTime = {
-    /**
-     * The initial skill modification identifier/level.
-     * @integer
-     * @minimum 1
-     * @maximum 6
-     */
-    initial_modification_level: number;
-};
-/**
- * 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.
- * @minProperties 1
- */
-export type CastingTimeIncludingLovemaking<NonModifiable extends Object> = {
-    /**
-     * The default casting time definition.
-     */
-    default?: CastingTime<NonModifiable>;
-    /**
-     * 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.
-     */
-    during_lovemaking?: CastingTimeDuringLovemaking;
-};
-/**
- * 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.
- */
-export type CastingTimeDuringLovemaking = {
-    /**
-     * The (unitless) casting time value.
-     * @integer
-     * @minimum 1
-     */
-    value: number;
-    /**
-     * The unit of the `value`.
-     */
-    unit: CastingTimeDuringLovemakingUnit;
-};
-export type CastingTimeDuringLovemakingUnit = "SeductionActions" | "Rounds";
-export type FastSkillNonModifiableCastingTime = {
-    /**
-     * The casting time value in actions.
-     * @integer
-     * @minimum 1
-     */
-    actions: number;
-};
-export type SlowSkillNonModifiableCastingTime = {
-    /**
-     * The (unitless) casting time value.
-     * @integer
-     * @minimum 1
-     */
-    value: number;
-    unit: SlowSkillCastingTimeUnit;
-};
-export type FastCastingTime = CastingTimeIncludingLovemaking<FastSkillNonModifiableCastingTime>;
-export type SlowCastingTime = CastingTimeIncludingLovemaking<SlowSkillNonModifiableCastingTime>;
+import { Enum, EnumCase, IncludeIdentifier, Integer, Object, TypeAlias, TypeArgument } from "tsondb/schema/def";
+export declare const CastingTime: Enum<"CastingTime", {
+    Modifiable: EnumCase<IncludeIdentifier<[], TypeAlias<"ModifiableCastingTime", Object<{
+        initial_modification_level: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+    }>, []>>>;
+    NonModifiable: EnumCase<TypeArgument<import("tsondb/schema/def").TypeParameter<"NonModifiable", import("tsondb/schema/def").Type>>>;
+}, [NonModifiable: import("tsondb/schema/def").TypeParameter<"NonModifiable", import("tsondb/schema/def").Type>]>;
+export declare const CastingTimeIncludingLovemaking: TypeAlias<"CastingTimeIncludingLovemaking", Object<{
+    default: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], Enum<"CastingTime", {
+        Modifiable: EnumCase<IncludeIdentifier<[], TypeAlias<"ModifiableCastingTime", Object<{
+            initial_modification_level: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+        }>, []>>>;
+        NonModifiable: EnumCase<TypeArgument<import("tsondb/schema/def").TypeParameter<"NonModifiable", import("tsondb/schema/def").Type>>>;
+    }, [NonModifiable: import("tsondb/schema/def").TypeParameter<"NonModifiable", import("tsondb/schema/def").Type>]>>, false>;
+    during_lovemaking: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"CastingTimeDuringLovemaking", Object<{
+        value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+        unit: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"CastingTimeDuringLovemakingUnit", {
+            SeductionActions: EnumCase<null>;
+            Rounds: EnumCase<null>;
+        }, []>>, true>;
+    }>, []>>, false>;
+}>, [NonModifiable: import("tsondb/schema/def").TypeParameter<"NonModifiable", import("tsondb/schema/def").Type>]>;
+export declare const CastingTimeDuringLovemaking: TypeAlias<"CastingTimeDuringLovemaking", Object<{
+    value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+    unit: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"CastingTimeDuringLovemakingUnit", {
+        SeductionActions: EnumCase<null>;
+        Rounds: EnumCase<null>;
+    }, []>>, true>;
+}>, []>;
+export declare const SlowSkillNonModifiableCastingTime: TypeAlias<"SlowSkillNonModifiableCastingTime", Object<{
+    value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+    unit: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"SlowSkillCastingTimeUnit", {
+        Minutes: EnumCase<null>;
+        Hours: EnumCase<null>;
+    }, []>>, true>;
+}>, []>;
+export declare const FastCastingTime: TypeAlias<"FastCastingTime", IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"CastingTimeIncludingLovemaking", Object<{
+    default: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], Enum<"CastingTime", {
+        Modifiable: EnumCase<IncludeIdentifier<[], TypeAlias<"ModifiableCastingTime", Object<{
+            initial_modification_level: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+        }>, []>>>;
+        NonModifiable: EnumCase<TypeArgument<import("tsondb/schema/def").TypeParameter<"NonModifiable", import("tsondb/schema/def").Type>>>;
+    }, [NonModifiable: import("tsondb/schema/def").TypeParameter<"NonModifiable", import("tsondb/schema/def").Type>]>>, false>;
+    during_lovemaking: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"CastingTimeDuringLovemaking", Object<{
+        value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+        unit: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"CastingTimeDuringLovemakingUnit", {
+            SeductionActions: EnumCase<null>;
+            Rounds: EnumCase<null>;
+        }, []>>, true>;
+    }>, []>>, false>;
+}>, [NonModifiable: import("tsondb/schema/def").TypeParameter<"NonModifiable", import("tsondb/schema/def").Type>]>>, []>;
+export declare const SlowCastingTime: TypeAlias<"SlowCastingTime", IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"CastingTimeIncludingLovemaking", Object<{
+    default: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], Enum<"CastingTime", {
+        Modifiable: EnumCase<IncludeIdentifier<[], TypeAlias<"ModifiableCastingTime", Object<{
+            initial_modification_level: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+        }>, []>>>;
+        NonModifiable: EnumCase<TypeArgument<import("tsondb/schema/def").TypeParameter<"NonModifiable", import("tsondb/schema/def").Type>>>;
+    }, [NonModifiable: import("tsondb/schema/def").TypeParameter<"NonModifiable", import("tsondb/schema/def").Type>]>>, false>;
+    during_lovemaking: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"CastingTimeDuringLovemaking", Object<{
+        value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+        unit: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"CastingTimeDuringLovemakingUnit", {
+            SeductionActions: EnumCase<null>;
+            Rounds: EnumCase<null>;
+        }, []>>, true>;
+    }>, []>>, false>;
+}>, [NonModifiable: import("tsondb/schema/def").TypeParameter<"NonModifiable", import("tsondb/schema/def").Type>]>>, []>;

package/lib/types/_ActivatableSkillCastingTime.js

@@ -1 +1,92 @@
-export {};
+import { Enum, EnumCase, GenEnum, GenIncludeIdentifier, GenTypeAlias, IncludeIdentifier, Integer, Object, Optional, Param, Required, TypeAlias, TypeArgument, } from "tsondb/schema/def";
+import { SlowSkillCastingTimeUnit } from "./SkillModificationLevel.js";
+import { SkillModificationLevelIdentifier } from "./_Identifier.js";
+export const CastingTime = GenEnum(import.meta.url, {
+    name: "CastingTime",
+    parameters: [Param("NonModifiable")],
+    values: NonModifiable => ({
+        Modifiable: EnumCase({ type: IncludeIdentifier(ModifiableCastingTime) }),
+        NonModifiable: EnumCase({ type: TypeArgument(NonModifiable) }),
+    }),
+});
+const ModifiableCastingTime = TypeAlias(import.meta.url, {
+    name: "ModifiableCastingTime",
+    type: () => Object({
+        initial_modification_level: Required({
+            comment: "The initial skill modification identifier/level.",
+            type: SkillModificationLevelIdentifier(),
+        }),
+    }),
+});
+export const CastingTimeIncludingLovemaking = 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: [Param("NonModifiable")],
+    type: NonModifiable => Object({
+        default: Optional({
+            comment: "The default casting time definition.",
+            type: GenIncludeIdentifier(CastingTime, [TypeArgument(NonModifiable)]),
+        }),
+        during_lovemaking: 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: IncludeIdentifier(CastingTimeDuringLovemaking),
+        }),
+    }, { minProperties: 1 }),
+});
+export const CastingTimeDuringLovemaking = 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: () => Object({
+        value: Required({
+            comment: "The (unitless) casting time value.",
+            type: Integer({ minimum: 1 }),
+        }),
+        unit: Required({
+            comment: "The unit of the `value`.",
+            type: IncludeIdentifier(CastingTimeDuringLovemakingUnit),
+        }),
+    }),
+});
+const CastingTimeDuringLovemakingUnit = Enum(import.meta.url, {
+    name: "CastingTimeDuringLovemakingUnit",
+    values: () => ({
+        SeductionActions: EnumCase({ type: null }),
+        Rounds: EnumCase({ type: null }),
+    }),
+});
+const FastSkillNonModifiableCastingTime = TypeAlias(import.meta.url, {
+    name: "FastSkillNonModifiableCastingTime",
+    type: () => Object({
+        actions: Required({
+            comment: "The casting time value in actions.",
+            type: Integer({ minimum: 1 }),
+        }),
+    }),
+});
+export const SlowSkillNonModifiableCastingTime = TypeAlias(import.meta.url, {
+    name: "SlowSkillNonModifiableCastingTime",
+    type: () => Object({
+        value: Required({
+            comment: "The (unitless) casting time value.",
+            type: Integer({ minimum: 1 }),
+        }),
+        unit: Required({
+            comment: "The unit of the `value`.",
+            type: IncludeIdentifier(SlowSkillCastingTimeUnit),
+        }),
+    }),
+});
+export const FastCastingTime = TypeAlias(import.meta.url, {
+    name: "FastCastingTime",
+    type: () => GenIncludeIdentifier(CastingTimeIncludingLovemaking, [
+        IncludeIdentifier(FastSkillNonModifiableCastingTime),
+    ]),
+});
+export const SlowCastingTime = TypeAlias(import.meta.url, {
+    name: "SlowCastingTime",
+    type: () => GenIncludeIdentifier(CastingTimeIncludingLovemaking, [
+        IncludeIdentifier(SlowSkillNonModifiableCastingTime),
+    ]),
+});

package/lib/types/_ActivatableSkillCheckResultBased.d.ts

@@ -1,33 +1,25 @@
-/**
- * Defines the derived (unitless) value.
- */
-export type CheckResultValue = "QualityLevels" | "SkillPoints";
-/**
- * Defines how the the `value` is set off against the check result.
- */
-export type CheckResultArithmetic = "Multiply" | "Divide";
-export type CheckResultBasedModifier = {
-    /**
-     * The arithmetic how to apply the `value` to the `base`.
-     */
-    arithmetic: CheckResultArithmetic;
-    /**
-     * The value that is applied to the `base` using the defined `arithmetic`.
-     * @integer
-     * @minimum 2
-     */
-    value: number;
-};
-/**
- * Defines a parameter being based on a check result.
- */
-export type CheckResultBased = {
-    /**
-     * The base value that is derived from the check result.
-     */
-    base: CheckResultValue;
-    /**
-     * If defined, it modifies the base value.
-     */
-    modifier?: CheckResultBasedModifier;
-};
+import { Enum, EnumCase, IncludeIdentifier, Integer, Object, TypeAlias } from "tsondb/schema/def";
+export declare const CheckResultValue: Enum<"CheckResultValue", {
+    QualityLevels: EnumCase<null>;
+    SkillPoints: EnumCase<null>;
+}, []>;
+export declare const CheckResultBasedModifier: 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>;
+}>, []>;
+export declare const CheckResultBased: TypeAlias<"CheckResultBased", Object<{
+    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>;
+}>, []>;

package/lib/types/_ActivatableSkillCheckResultBased.js

@@ -1 +1,44 @@
-export {};
+import { Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional, Required, TypeAlias, } from "tsondb/schema/def";
+export const CheckResultValue = Enum(import.meta.url, {
+    name: "CheckResultValue",
+    comment: "Defines the derived (unitless) value.",
+    values: () => ({
+        QualityLevels: EnumCase({ type: null }),
+        SkillPoints: EnumCase({ type: null }),
+    }),
+});
+const CheckResultArithmetic = Enum(import.meta.url, {
+    name: "CheckResultArithmetic",
+    comment: "Defines how the the `value` is set off against the check result.",
+    values: () => ({
+        Multiply: EnumCase({ type: null }),
+        Divide: EnumCase({ type: null }),
+    }),
+});
+export const CheckResultBasedModifier = TypeAlias(import.meta.url, {
+    name: "CheckResultBasedModifier",
+    type: () => Object({
+        arithmetic: Required({
+            comment: "The arithmetic how to apply the `value` to the `base`.",
+            type: IncludeIdentifier(CheckResultArithmetic),
+        }),
+        value: Required({
+            comment: "The value that is applied to the `base` using the defined `arithmetic`.",
+            type: Integer({ minimum: 2 }),
+        }),
+    }),
+});
+export const CheckResultBased = TypeAlias(import.meta.url, {
+    name: "CheckResultBased",
+    comment: "Defines a parameter being based on a check result.",
+    type: () => Object({
+        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),
+        }),
+    }),
+});