optolith-database-schema 0.17.2 → 0.18.2

package/lib/types/_ActivatableSkillCost.js

@@ -1 +1,224 @@
-export {};
+import { Array, Boolean, Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional, Required, TypeAlias, } from "tsondb/schema/def";
+import { DurationUnitValue } from "./_ActivatableSkillDuration.js";
+import { SkillModificationLevelIdentifier } from "./_Identifier.js";
+import { ResponsiveText, ResponsiveTextOptional, ResponsiveTextReplace } from "./_ResponsiveText.js";
+import { NestedLocaleMap } from "./Locale.js";
+export const OneTimeCost = Enum(import.meta.url, {
+    name: "OneTimeCost",
+    values: () => ({
+        Single: EnumCase({ type: IncludeIdentifier(SingleOneTimeCost) }),
+        Conjunction: EnumCase({ type: IncludeIdentifier(MultipleOneTimeCosts) }),
+        Disjunction: EnumCase({ type: IncludeIdentifier(MultipleOneTimeCosts) }),
+        Map: EnumCase({ type: IncludeIdentifier(CostMap) }),
+    }),
+});
+const SingleOneTimeCost = Enum(import.meta.url, {
+    name: "SingleOneTimeCost",
+    values: () => ({
+        Modifiable: EnumCase({ type: IncludeIdentifier(ModifiableOneTimeCost) }),
+        NonModifiable: EnumCase({ type: IncludeIdentifier(NonModifiableOneTimeCost) }),
+        Indefinite: EnumCase({ type: IncludeIdentifier(IndefiniteOneTimeCost) }),
+    }),
+});
+const MultipleOneTimeCosts = TypeAlias(import.meta.url, {
+    name: "MultipleOneTimeCosts",
+    type: () => Array(IncludeIdentifier(SingleOneTimeCost), {
+        minItems: 2,
+    }),
+});
+const ModifiableOneTimeCost = TypeAlias(import.meta.url, {
+    name: "ModifiableOneTimeCost",
+    type: () => Object({
+        initial_modification_level: Required({
+            comment: "The initial skill modification identifier/level.",
+            type: SkillModificationLevelIdentifier(),
+        }),
+        permanent_value: Optional({
+            comment: "The part of the cost value that has to be spent permanently.",
+            type: Integer({ minimum: 1 }),
+        }),
+        translations: NestedLocaleMap(Optional, "ModifiableOneTimeCostTranslation", Object({
+            replacement: Required({
+                comment: "A replacement string.",
+                type: IncludeIdentifier(ResponsiveTextReplace),
+            }),
+        })),
+    }),
+});
+const NonModifiableOneTimeCost = TypeAlias(import.meta.url, {
+    name: "NonModifiableOneTimeCost",
+    type: () => Object({
+        is_minimum: Optional({
+            comment: "If `true`, the non-modifiable value is a minimum value.",
+            type: Boolean(),
+        }),
+        value: Required({
+            comment: "The AE cost value.",
+            type: Integer({ minimum: 1 }),
+        }),
+        permanent_value: Optional({
+            comment: "The part of the cost value that has to be spent permanently.",
+            type: Integer({ minimum: 1 }),
+        }),
+        per: Optional({
+            comment: "The cost have to be per a specific countable entity, e.g. `8 KP per person`.",
+            type: IncludeIdentifier(NonModifiableOneTimeCostPerCountable),
+        }),
+        translations: NestedLocaleMap(Optional, "NonModifiableOneTimeCostTranslation", Object({
+            note: Required({
+                comment: "A note, appended to the generated string in parenthesis.",
+                type: IncludeIdentifier(ResponsiveTextOptional),
+            }),
+        })),
+    }),
+});
+const NonModifiableOneTimeCostPerCountable = TypeAlias(import.meta.url, {
+    name: "NonModifiableOneTimeCostPerCountable",
+    type: () => Object({
+        minimum_total: Optional({
+            comment: "If defined, the minimum total AE that have to be spent casting the skill.",
+            type: Integer({ minimum: 1 }),
+        }),
+        translations: NestedLocaleMap(Optional, "NonModifiableOneTimeCostPerCountableTranslation", Object({
+            countable: Required({
+                comment: "The countable entity name.",
+                type: IncludeIdentifier(ResponsiveText),
+            }),
+        })),
+    }),
+});
+export const IndefiniteOneTimeCost = TypeAlias(import.meta.url, {
+    name: "IndefiniteOneTimeCost",
+    type: () => Object({
+        translations: NestedLocaleMap(Required, "IndefiniteOneTimeCostTranslation", Object({
+            description: Required({
+                comment: "A description of where the cost come from.",
+                type: IncludeIdentifier(ResponsiveText),
+            }),
+        })),
+    }),
+});
+export const CostMap = TypeAlias(import.meta.url, {
+    name: "CostMap",
+    comment: `A content that is \`2/4/8/16 AE for an item the size of a cup/chest/door/castle gate\` may be respresented as the following map:
+
+\`\`\`yaml
+options:
+  - value: 2
+    label: "cup"
+  - value: 4
+    label: "chest"
+  - value: 8
+    label: "door"
+  - value: 16
+    label: "castle gate"
+for_append: "an item the size of a"
+\`\`\`
+
+This will generate the exact same string as seen above – given it is set for a spellwork and thus \`AE\` is used.`,
+    type: () => Object({
+        options: Required({
+            comment: "The possible costs and associated labels.",
+            type: Array(IncludeIdentifier(CostMapOption), {
+                minItems: 2,
+            }),
+        }),
+        translations: NestedLocaleMap(Optional, "CostMapTranslation", Object({
+            list_prepend: Optional({
+                comment: "Place a string between the `for` and the grouped map option labels.",
+                type: IncludeIdentifier(ResponsiveTextOptional),
+            }),
+            list_append: Optional({
+                comment: "Place a string after the grouped map option labels.",
+                type: IncludeIdentifier(ResponsiveTextOptional),
+            }),
+            replacement: Optional({
+                comment: "If the string from the book cannot be generated using the default generation technique, use this string. All options still need to be inserted propertly, since it may be used by in-game tools to provide a selection to players.",
+                type: IncludeIdentifier(ResponsiveTextOptional),
+            }),
+        }, { minProperties: 1 })),
+    }),
+});
+const CostMapOption = TypeAlias(import.meta.url, {
+    name: "CostMapOption",
+    type: () => Object({
+        value: Required({
+            comment: "The full cost value for this option.",
+            type: Integer({ minimum: 1 }),
+        }),
+        permanent_value: Optional({
+            comment: "The part of the `value` that has to be paid permanently.",
+            type: Integer({ minimum: 0 }),
+        }),
+        translations: NestedLocaleMap(Optional, "CostMapOptionTranslation", Object({
+            label: Required({
+                comment: "The description of the option for cost string generation.",
+                type: IncludeIdentifier(ResponsiveTextOptional),
+            }),
+            label_standalone: Optional({
+                comment: "The description of the option if used standalone. Only used if different from `label`.",
+                type: IncludeIdentifier(ResponsiveTextOptional),
+            }),
+        })),
+    }),
+});
+export const SustainedCost = Enum(import.meta.url, {
+    name: "SustainedCost",
+    values: () => ({
+        Modifiable: EnumCase({
+            type: IncludeIdentifier(ModifiableSustainedCost),
+        }),
+        NonModifiable: EnumCase({
+            type: IncludeIdentifier(NonModifiableSustainedCost),
+        }),
+    }),
+});
+const ModifiableSustainedCost = TypeAlias(import.meta.url, {
+    name: "ModifiableSustainedCost",
+    type: () => Object({
+        initial_modification_level: Required({
+            comment: "The initial skill modification identifier/level.",
+            type: SkillModificationLevelIdentifier(),
+        }),
+        interval: Required({
+            comment: "The sustain interval.",
+            type: IncludeIdentifier(DurationUnitValue),
+        }),
+    }),
+});
+const NonModifiableSustainedCost = TypeAlias(import.meta.url, {
+    name: "NonModifiableSustainedCost",
+    type: () => Object({
+        is_minimum: Optional({
+            comment: "If `true`, the non-modifiable value is a minimum value.",
+            type: Boolean(),
+        }),
+        value: Required({
+            comment: "The AE cost value.",
+            type: Integer({ minimum: 1 }),
+        }),
+        per: Optional({
+            comment: "The cost have to be per a specific countable entity, e.g. `8 KP per person`.",
+            type: IncludeIdentifier(NonModifiableSustainedCostPerCountable),
+        }),
+        interval: Required({
+            comment: "The sustain interval.",
+            type: IncludeIdentifier(DurationUnitValue),
+        }),
+    }),
+});
+const NonModifiableSustainedCostPerCountable = TypeAlias(import.meta.url, {
+    name: "NonModifiableSustainedCostPerCountable",
+    type: () => Object({
+        minimum_total: Optional({
+            comment: "If defined, the minimum total AE that have to be spent casting the skill.",
+            type: Integer({ minimum: 1 }),
+        }),
+        translations: NestedLocaleMap(Required, "NonModifiableSustainedCostPerCountableTranslation", Object({
+            countable: Required({
+                comment: "The countable entity name.",
+                type: IncludeIdentifier(ResponsiveText),
+            }),
+        })),
+    }),
+});

package/lib/types/_ActivatableSkillDuration.d.ts

@@ -1,135 +1,202 @@
-import { CheckResultBasedModifier, CheckResultValue } from "./_ActivatableSkillCheckResultBased.js";
-import { LocaleMap } from "./_LocaleMap.js";
-import { ResponsiveText, ResponsiveTextReplace } from "./_ResponsiveText.js";
-export type DurationForOneTime = {
-    tag: "Immediate";
-    immediate: Immediate;
-} | {
-    tag: "Permanent";
-    permanent: PermanentDuration;
-} | {
-    tag: "Fixed";
-    fixed: FixedDuration;
-} | {
-    tag: "CheckResultBased";
-    check_result_based: CheckResultBasedDuration;
-} | {
-    tag: "Indefinite";
-    indefinite: IndefiniteDuration;
-};
-export type Immediate = {
-    /**
-     * Specified if the duration has a maximum time span.
-     */
-    maximum?: DurationUnitValue;
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations?: LocaleMap<ImmediateTranslation>;
-};
-export type ImmediateTranslation = {
-    /**
-     * A replacement string.
-     */
-    replacement: ResponsiveTextReplace;
-};
-export type PermanentDuration = {
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations?: LocaleMap<PermanentDurationTranslation>;
-};
-export type PermanentDurationTranslation = {
-    /**
-     * A replacement string.
-     */
-    replacement: ResponsiveTextReplace;
-};
-export type FixedDuration = {
-    /**
-     * If the duration is the maximum duration, so it may end earlier.
-     */
-    is_maximum?: true;
-    /**
-     * The (unitless) duration.
-     * @integer
-     * @minimum 1
-     */
-    value: number;
-    /**
-     * The duration unit.
-     */
-    unit: DurationUnit;
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations?: LocaleMap<FixedDurationTranslation>;
-};
-export type FixedDurationTranslation = {
-    /**
-     * A replacement string.
-     */
-    replacement: ResponsiveTextReplace;
-};
-/**
- * Defines the duration being based on a check result.
- */
-export type CheckResultBasedDuration = {
-    /**
-     * If the duration is the maximum duration, so it may end earlier.
-     */
-    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: DurationUnit;
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations?: LocaleMap<CheckResultBasedDurationTranslation>;
-};
-export type CheckResultBasedDurationTranslation = {
-    /**
-     * A replacement string.
-     */
-    replacement: ResponsiveTextReplace;
-};
-export type IndefiniteDuration = {
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations: LocaleMap<IndefiniteDurationTranslation>;
-};
-export type IndefiniteDurationTranslation = {
-    /**
-     * A description of the duration.
-     */
-    description: ResponsiveText;
-};
-export type DurationForSustained = {
-    /**
-     * The sustained skill can be active a maximum amount of time.
-     */
-    maximum: DurationUnitValue;
-};
-export type DurationUnit = "Seconds" | "Minutes" | "Hours" | "Days" | "Weeks" | "Months" | "Years" | "Centuries" | "Actions" | "CombatRounds";
-export type DurationUnitValue = {
-    /**
-     * The (unitless) duration value.
-     * @integer
-     * @minimum 1
-     */
-    value: number;
-    /**
-     * The unit of the `value`.
-     */
-    unit: DurationUnit;
-};
+import { Boolean, Enum, EnumCase, IncludeIdentifier, Integer, Object, TypeAlias } from "tsondb/schema/def";
+export declare const DurationForOneTime: Enum<"DurationForOneTime", {
+    Immediate: EnumCase<IncludeIdentifier<[], TypeAlias<"Immediate", Object<{
+        maximum: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"DurationUnitValue", Object<{
+            value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+            unit: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DurationUnit", {
+                Seconds: EnumCase<null>;
+                Minutes: EnumCase<null>;
+                Hours: EnumCase<null>;
+                Days: EnumCase<null>;
+                Weeks: EnumCase<null>;
+                Months: EnumCase<null>;
+                Years: EnumCase<null>;
+                Centuries: EnumCase<null>;
+                Actions: EnumCase<null>;
+                CombatRounds: EnumCase<null>;
+            }, []>>, true>;
+        }>, []>>, false>;
+        translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"ImmediateTranslation", {
+            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>;
+    }>, []>>>;
+    Permanent: EnumCase<IncludeIdentifier<[], TypeAlias<"PermanentDuration", Object<{
+        translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"PermanentDurationTranslation", {
+            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>;
+    }>, []>>>;
+    Fixed: EnumCase<IncludeIdentifier<[], TypeAlias<"FixedDuration", 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<"DurationUnit", {
+            Seconds: EnumCase<null>;
+            Minutes: EnumCase<null>;
+            Hours: EnumCase<null>;
+            Days: EnumCase<null>;
+            Weeks: EnumCase<null>;
+            Months: EnumCase<null>;
+            Years: EnumCase<null>;
+            Centuries: EnumCase<null>;
+            Actions: EnumCase<null>;
+            CombatRounds: EnumCase<null>;
+        }, []>>, true>;
+        translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"FixedDurationTranslation", {
+            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>;
+    }>, []>>>;
+    CheckResultBased: EnumCase<IncludeIdentifier<[], TypeAlias<"CheckResultBasedDuration", 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<"DurationUnit", {
+            Seconds: EnumCase<null>;
+            Minutes: EnumCase<null>;
+            Hours: EnumCase<null>;
+            Days: EnumCase<null>;
+            Weeks: EnumCase<null>;
+            Months: EnumCase<null>;
+            Years: EnumCase<null>;
+            Centuries: EnumCase<null>;
+            Actions: EnumCase<null>;
+            CombatRounds: EnumCase<null>;
+        }, []>>, true>;
+        translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"CheckResultBasedDurationTranslation", {
+            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>;
+    }>, []>>>;
+    Indefinite: EnumCase<IncludeIdentifier<[], TypeAlias<"IndefiniteDuration", Object<{
+        translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"IndefiniteDurationTranslation", {
+            description: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ResponsiveText", 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>;
+            }>, []>>, true>;
+        }>, true>;
+    }>, []>>>;
+}, []>;
+export declare const FixedDuration: TypeAlias<"FixedDuration", 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<"DurationUnit", {
+        Seconds: EnumCase<null>;
+        Minutes: EnumCase<null>;
+        Hours: EnumCase<null>;
+        Days: EnumCase<null>;
+        Weeks: EnumCase<null>;
+        Months: EnumCase<null>;
+        Years: EnumCase<null>;
+        Centuries: EnumCase<null>;
+        Actions: EnumCase<null>;
+        CombatRounds: EnumCase<null>;
+    }, []>>, true>;
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"FixedDurationTranslation", {
+        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 CheckResultBasedDuration: TypeAlias<"CheckResultBasedDuration", 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<"DurationUnit", {
+        Seconds: EnumCase<null>;
+        Minutes: EnumCase<null>;
+        Hours: EnumCase<null>;
+        Days: EnumCase<null>;
+        Weeks: EnumCase<null>;
+        Months: EnumCase<null>;
+        Years: EnumCase<null>;
+        Centuries: EnumCase<null>;
+        Actions: EnumCase<null>;
+        CombatRounds: EnumCase<null>;
+    }, []>>, true>;
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"CheckResultBasedDurationTranslation", {
+        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 IndefiniteDuration: TypeAlias<"IndefiniteDuration", Object<{
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"IndefiniteDurationTranslation", {
+        description: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ResponsiveText", 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>;
+        }>, []>>, true>;
+    }>, true>;
+}>, []>;
+export declare const DurationForSustained: TypeAlias<"DurationForSustained", Object<{
+    maximum: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"DurationUnitValue", Object<{
+        value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+        unit: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DurationUnit", {
+            Seconds: EnumCase<null>;
+            Minutes: EnumCase<null>;
+            Hours: EnumCase<null>;
+            Days: EnumCase<null>;
+            Weeks: EnumCase<null>;
+            Months: EnumCase<null>;
+            Years: EnumCase<null>;
+            Centuries: EnumCase<null>;
+            Actions: EnumCase<null>;
+            CombatRounds: EnumCase<null>;
+        }, []>>, true>;
+    }>, []>>, true>;
+}>, []>;
+export declare const DurationUnit: Enum<"DurationUnit", {
+    Seconds: EnumCase<null>;
+    Minutes: EnumCase<null>;
+    Hours: EnumCase<null>;
+    Days: EnumCase<null>;
+    Weeks: EnumCase<null>;
+    Months: EnumCase<null>;
+    Years: EnumCase<null>;
+    Centuries: EnumCase<null>;
+    Actions: EnumCase<null>;
+    CombatRounds: EnumCase<null>;
+}, []>;
+export declare const DurationUnitValue: TypeAlias<"DurationUnitValue", Object<{
+    value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+    unit: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DurationUnit", {
+        Seconds: EnumCase<null>;
+        Minutes: EnumCase<null>;
+        Hours: EnumCase<null>;
+        Days: EnumCase<null>;
+        Weeks: EnumCase<null>;
+        Months: EnumCase<null>;
+        Years: EnumCase<null>;
+        Centuries: EnumCase<null>;
+        Actions: EnumCase<null>;
+        CombatRounds: EnumCase<null>;
+    }, []>>, true>;
+}>, []>;