optolith-database-schema 0.17.2 → 0.18.2

package/lib/types/prerequisites/single/SexPrerequisite.d.ts

@@ -1,10 +1,19 @@
-import { BinarySex } from "../../_Sex.js";
-import { DisplayOption } from "../DisplayOption.js";
-/**
- * Requires a specific sex.
- * @title Sex Prerequisite
- */
-export type SexPrerequisite = {
-    id: BinarySex;
-    display_option?: DisplayOption;
-};
+import { IncludeIdentifier, Object, TypeAlias } from "tsondb/schema/def";
+export declare const SexPrerequisite: TypeAlias<"SexPrerequisite", Object<{
+    id: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"BinarySex", {
+        Male: import("tsondb/schema/def").EnumCaseDecl<null>;
+        Female: import("tsondb/schema/def").EnumCaseDecl<null>;
+    }, []>>, true>;
+    display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"DisplayOption", {
+        Hide: import("tsondb/schema/def").EnumCaseDecl<null>;
+        ReplaceWith: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"ReplacementDisplayOption", Object<{
+            sentence_type: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"SentenceType", {
+                Standalone: import("tsondb/schema/def").EnumCaseDecl<null>;
+                Connected: import("tsondb/schema/def").EnumCaseDecl<null>;
+            }, []>>, false>;
+            translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"ReplacementDisplayOptionTranslation", {
+                replacement: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;

package/lib/types/prerequisites/single/SexPrerequisite.js

@@ -1 +1,15 @@
-export {};
+import { IncludeIdentifier, Object, Optional, Required, TypeAlias } from "tsondb/schema/def";
+import { BinarySex } from "../../_Sex.js";
+import { DisplayOption } from "../DisplayOption.js";
+export const SexPrerequisite = TypeAlias(import.meta.url, {
+    name: "SexPrerequisite",
+    comment: "Requires a specific sex.",
+    type: () => Object({
+        id: Required({
+            type: IncludeIdentifier(BinarySex),
+        }),
+        display_option: Optional({
+            type: IncludeIdentifier(DisplayOption),
+        }),
+    }),
+});

package/lib/types/prerequisites/single/SexualCharacteristicPrerequisite.d.ts

@@ -1,8 +1,7 @@
-/**
- * Requires a specific sexual characteristic.
- * @title Sexual Characteristic Prerequisite
- */
-export type SexualCharacteristicPrerequisite = {
-    id: SexualCharacteristic;
-};
-export type SexualCharacteristic = "Penis" | "Vagina";
+import { Enum, EnumCase, IncludeIdentifier, Object, TypeAlias } from "tsondb/schema/def";
+export declare const SexualCharacteristicPrerequisite: TypeAlias<"SexualCharacteristicPrerequisite", Object<{
+    id: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"SexualCharacteristic", {
+        Penis: EnumCase<null>;
+        Vagina: EnumCase<null>;
+    }, []>>, true>;
+}>, []>;

package/lib/types/prerequisites/single/SexualCharacteristicPrerequisite.js

@@ -1 +1,17 @@
-export {};
+import { Enum, EnumCase, IncludeIdentifier, Object, Required, TypeAlias } from "tsondb/schema/def";
+export const SexualCharacteristicPrerequisite = TypeAlias(import.meta.url, {
+    name: "SexualCharacteristicPrerequisite",
+    comment: "Requires a specific sexual characteristic.",
+    type: () => Object({
+        id: Required({
+            type: IncludeIdentifier(SexualCharacteristic),
+        }),
+    }),
+});
+const SexualCharacteristic = Enum(import.meta.url, {
+    name: "SexualCharacteristic",
+    values: () => ({
+        Penis: EnumCase({ type: null }),
+        Vagina: EnumCase({ type: null }),
+    }),
+});

package/lib/types/prerequisites/single/SocialStatusPrerequisite.d.ts

@@ -1,13 +1,16 @@
-import { SocialStatusIdentifier } from "../../_Identifier.js";
-import { DisplayOption } from "../DisplayOption.js";
-/**
- * Requires a minimum social status.
- * @title Social Status Prerequisite
- */
-export type SocialStatusPrerequisite = {
-    /**
-     * The minimum social status' identifier.
-     */
-    id: SocialStatusIdentifier;
-    display_option?: DisplayOption;
-};
+import { IncludeIdentifier, Object, TypeAlias } from "tsondb/schema/def";
+export declare const SocialStatusPrerequisite: TypeAlias<"SocialStatusPrerequisite", Object<{
+    id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+    display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"DisplayOption", {
+        Hide: import("tsondb/schema/def").EnumCaseDecl<null>;
+        ReplaceWith: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"ReplacementDisplayOption", Object<{
+            sentence_type: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"SentenceType", {
+                Standalone: import("tsondb/schema/def").EnumCaseDecl<null>;
+                Connected: import("tsondb/schema/def").EnumCaseDecl<null>;
+            }, []>>, false>;
+            translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"ReplacementDisplayOptionTranslation", {
+                replacement: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;

package/lib/types/prerequisites/single/SocialStatusPrerequisite.js

@@ -1 +1,16 @@
-export {};
+import { IncludeIdentifier, Object, Optional, Required, TypeAlias } from "tsondb/schema/def";
+import { SocialStatusIdentifier } from "../../_Identifier.js";
+import { DisplayOption } from "../DisplayOption.js";
+export const SocialStatusPrerequisite = TypeAlias(import.meta.url, {
+    name: "SocialStatusPrerequisite",
+    comment: "Requires a minimum social status.",
+    type: () => Object({
+        id: Required({
+            comment: "The minimum social status’s identifier.",
+            type: SocialStatusIdentifier(),
+        }),
+        display_option: Optional({
+            type: IncludeIdentifier(DisplayOption),
+        }),
+    }),
+});

package/lib/types/prerequisites/single/StatePrerequisite.d.ts

@@ -1,10 +1,16 @@
-import { StateIdentifier } from "../../_Identifier.js";
-import { DisplayOption } from "../DisplayOption.js";
-/**
- * Requires a specific state or one of a specific set of states.
- * @title State Prerequisite
- */
-export type StatePrerequisite = {
-    id: StateIdentifier;
-    display_option?: DisplayOption;
-};
+import { IncludeIdentifier, Object, TypeAlias } from "tsondb/schema/def";
+export declare const StatePrerequisite: TypeAlias<"StatePrerequisite", Object<{
+    id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+    display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"DisplayOption", {
+        Hide: import("tsondb/schema/def").EnumCaseDecl<null>;
+        ReplaceWith: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"ReplacementDisplayOption", Object<{
+            sentence_type: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"SentenceType", {
+                Standalone: import("tsondb/schema/def").EnumCaseDecl<null>;
+                Connected: import("tsondb/schema/def").EnumCaseDecl<null>;
+            }, []>>, false>;
+            translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"ReplacementDisplayOptionTranslation", {
+                replacement: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;

package/lib/types/prerequisites/single/StatePrerequisite.js

@@ -1 +1,15 @@
-export {};
+import { IncludeIdentifier, Object, Optional, Required, TypeAlias } from "tsondb/schema/def";
+import { StateIdentifier } from "../../_Identifier.js";
+import { DisplayOption } from "../DisplayOption.js";
+export const StatePrerequisite = TypeAlias(import.meta.url, {
+    name: "StatePrerequisite",
+    comment: "Requires a specific state to be active.",
+    type: () => Object({
+        id: Required({
+            type: StateIdentifier(),
+        }),
+        display_option: Optional({
+            type: IncludeIdentifier(DisplayOption),
+        }),
+    }),
+});

package/lib/types/prerequisites/single/TextPrerequisite.d.ts

@@ -1,49 +1,19 @@
-import { LocaleMap } from "../../_LocaleMap.js";
-import { NonEmptyMarkdown } from "../../_NonEmptyString.js";
-/**
- * A prerequisite that is either not verifyable in general – e.g. roleplay or
- * background information – or the referenced entities were not made available
- * for use yet – e.g. races –, but which should be displayed, because it is part
- * of the prerequisite string from the sources.
- * @title Text Prerequisite
- */
-export type TextPrerequisite = {
-    /**
-     * The method how the prerequisite should be verified. Either is passes all
-     * verification text or it denies all verification tests. The latter results
-     * in the associated entry to never be available for purchase.
-     */
-    verification: TextVerificationRule;
-    /**
-     * If the text is a sentence or sentence-like fragment, this property ensures
-     * it is integrated into the prerequisite string correctly.
-     *
-     * A standalone sentence is connected to the previous prerequisite string with
-     * a period and a period is also added at the end of the sentence
-     * automatically, if it is not present. A connected sentence is connected to
-     * the previous prerequisite string with a semicolon and a period is not added
-     * to the end of the sentence. In this case, if there are prerequisites after
-     * this one, they will be connected using a semicolon again, unless a
-     * different punctuation mark is present at the end of the given text.
-     */
-    sentence_type?: SentenceType;
-    /**
-     * If the text does not represent an actual prerequisite but a prerequisite
-     * for the use of certain aspects or the entry the prerequisite is associated
-     * with, or something like that, this property is set to `true`.
-     *
-     * If all prerequisites of an entry are marked as meta, the entry is
-     * considered to have no prerequisites and thus the string `none` must be
-     * rendered before the list of meta prerequisites.
-     *
-     * This is the only use case for this property.
-     */
-    is_meta?: true;
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations: LocaleMap<TextPrerequisiteTranslation>;
-};
-export type TextVerificationRule = "Pass" | "Deny";
-export type SentenceType = "Standalone" | "Connected";
-export type TextPrerequisiteTranslation = NonEmptyMarkdown;
+import { Boolean, Enum, EnumCase, IncludeIdentifier, Object, String, TypeAlias } from "tsondb/schema/def";
+export declare const TextPrerequisite: TypeAlias<"TextPrerequisite", Object<{
+    verification: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"TextVerificationRule", {
+        Pass: EnumCase<null>;
+        Deny: EnumCase<null>;
+    }, []>>, true>;
+    sentence_type: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"SentenceType", {
+        Standalone: EnumCase<null>;
+        Connected: EnumCase<null>;
+    }, []>>, false>;
+    is_meta: import("tsondb/schema/def").MemberDecl<Boolean, false>;
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"TextPrerequisiteTranslation", {
+        text: import("tsondb/schema/def").MemberDecl<String, true>;
+    }>, true>;
+}>, []>;
+export declare const SentenceType: Enum<"SentenceType", {
+    Standalone: EnumCase<null>;
+    Connected: EnumCase<null>;
+}, []>;

package/lib/types/prerequisites/single/TextPrerequisite.js

@@ -1 +1,53 @@
-export {};
+import { Boolean, Enum, EnumCase, IncludeIdentifier, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
+import { NestedLocaleMap } from "../../Locale.js";
+export const TextPrerequisite = TypeAlias(import.meta.url, {
+    name: "TextPrerequisite",
+    comment: "A prerequisite that is either not verifyable in general – e.g. roleplay or background information – or the referenced entities were not made available for use yet – e.g. races –, but which should be displayed, because it is part of the prerequisite string from the sources.",
+    type: () => Object({
+        verification: Required({
+            comment: "The method how the prerequisite should be verified. Either is passes all verification text or it denies all verification tests. The latter results in the associated entry to never be available for purchase.",
+            type: IncludeIdentifier(TextVerificationRule),
+        }),
+        sentence_type: Optional({
+            comment: `If the text is a sentence or sentence-like fragment, this property ensures it is integrated into the prerequisite string correctly.
+
+A standalone sentence is connected to the previous prerequisite string with a period and a period is also added at the end of the sentence automatically, if it is not present. A connected sentence is connected to the previous prerequisite string with a semicolon and a period is not added to the end of the sentence. In this case, if there are prerequisites after this one, they will be connected using a semicolon again, unless a different punctuation mark is present at the end of the given text.`,
+            type: IncludeIdentifier(SentenceType),
+        }),
+        is_meta: Optional({
+            comment: `If the text does not represent an actual prerequisite but a prerequisite for the use of certain aspects or the entry the prerequisite is associated with, or something like that, this property is set to \`true\`.
+
+If all prerequisites of an entry are marked as meta, the entry is considered to have no prerequisites and thus the string \`none\` must be rendered before the list of meta prerequisites.
+
+This is the only use case for this property.`,
+            type: Boolean(),
+        }),
+        translations: NestedLocaleMap(Required, "TextPrerequisiteTranslation", Object({
+            text: Required({
+                comment: "The displayed text.",
+                type: String({ minLength: 1, isMarkdown: true }),
+            }),
+        })),
+    }),
+});
+const TextVerificationRule = Enum(import.meta.url, {
+    name: "TextVerificationRule",
+    values: () => ({
+        Pass: EnumCase({ type: null }),
+        Deny: EnumCase({ type: null }),
+    }),
+});
+export const SentenceType = Enum(import.meta.url, {
+    name: "SentenceType",
+    comment: "If the text is a sentence or sentence-like fragment, this defines how it is integrated into the prerequisite string correctly.",
+    values: () => ({
+        Standalone: EnumCase({
+            comment: "A standalone sentence is connected to the previous prerequisite string with a period and a period is also added at the end of the sentence automatically, if it is not present.",
+            type: null,
+        }),
+        Connected: EnumCase({
+            comment: "A connected sentence is connected to the previous prerequisite string with a semicolon and a period is not added to the end of the sentence. In this case, if there are prerequisites after this one, they will be connected using a semicolon again, unless a different punctuation mark is present at the end of the given text.",
+            type: null,
+        }),
+    }),
+});

package/lib/types/prerequisites/single/TraditionPrerequisite.d.ts

@@ -1,33 +1,37 @@
-import { DisplayOption } from "../DisplayOption.js";
-/**
- * @title Blessed Tradition Prerequisite
- */
-export type BlessedTraditionPrerequisite = {
-    /**
-     * The blessed tradition prerequisite may only be satified if the blessed
-     * tradition is either church or shamanistic.
-     */
-    restriction?: BlessedTraditionPrerequisiteRestriction;
-    display_option?: DisplayOption;
-};
-/**
- * The blessed tradition prerequisite may only be satified if the blessed
- * tradition is either church or shamanistic.
- */
-export type BlessedTraditionPrerequisiteRestriction = "Church" | "Shamanistic";
-/**
- * @title Magical Tradition Prerequisite
- */
-export type MagicalTraditionPrerequisite = {
-    /**
-     * The magical tradition prerequisite may only be satified if the magical
-     * tradition can learn rituals or can bind familiars.
-     */
-    restriction?: MagicalTraditionPrerequisiteRestriction;
-    display_option?: DisplayOption;
-};
-/**
- * The magical tradition prerequisite may only be satified if the magical
- * tradition can learn rituals or can bind familiars.
- */
-export type MagicalTraditionPrerequisiteRestriction = "CanLearnRituals" | "CanBindFamiliars";
+import { Enum, EnumCase, IncludeIdentifier, Object, TypeAlias } from "tsondb/schema/def";
+export declare const BlessedTraditionPrerequisite: TypeAlias<"BlessedTraditionPrerequisite", Object<{
+    restriction: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"BlessedTraditionPrerequisiteRestriction", {
+        Church: EnumCase<null>;
+        Shamanistic: EnumCase<null>;
+    }, []>>, false>;
+    display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DisplayOption", {
+        Hide: EnumCase<null>;
+        ReplaceWith: EnumCase<IncludeIdentifier<[], TypeAlias<"ReplacementDisplayOption", Object<{
+            sentence_type: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"SentenceType", {
+                Standalone: EnumCase<null>;
+                Connected: EnumCase<null>;
+            }, []>>, false>;
+            translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"ReplacementDisplayOptionTranslation", {
+                replacement: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;
+export declare const MagicalTraditionPrerequisite: TypeAlias<"MagicalTraditionPrerequisite", Object<{
+    restriction: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"MagicalTraditionPrerequisiteRestriction", {
+        CanLearnRituals: EnumCase<null>;
+        CanBindFamiliars: EnumCase<null>;
+    }, []>>, false>;
+    display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DisplayOption", {
+        Hide: EnumCase<null>;
+        ReplaceWith: EnumCase<IncludeIdentifier<[], TypeAlias<"ReplacementDisplayOption", Object<{
+            sentence_type: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"SentenceType", {
+                Standalone: EnumCase<null>;
+                Connected: EnumCase<null>;
+            }, []>>, false>;
+            translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"ReplacementDisplayOptionTranslation", {
+                replacement: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;

package/lib/types/prerequisites/single/TraditionPrerequisite.js

@@ -1 +1,42 @@
-export {};
+import { Enum, EnumCase, IncludeIdentifier, Object, Optional, TypeAlias } from "tsondb/schema/def";
+import { DisplayOption } from "../DisplayOption.js";
+export const BlessedTraditionPrerequisite = TypeAlias(import.meta.url, {
+    name: "BlessedTraditionPrerequisite",
+    type: () => Object({
+        restriction: Optional({
+            comment: "The blessed tradition prerequisite may only be satified if the blessed tradition is either church or shamanistic.",
+            type: IncludeIdentifier(BlessedTraditionPrerequisiteRestriction),
+        }),
+        display_option: Optional({
+            type: IncludeIdentifier(DisplayOption),
+        }),
+    }),
+});
+const BlessedTraditionPrerequisiteRestriction = Enum(import.meta.url, {
+    name: "BlessedTraditionPrerequisiteRestriction",
+    comment: "The blessed tradition prerequisite may only be satified if the blessed tradition is either church or shamanistic.",
+    values: () => ({
+        Church: EnumCase({ type: null }),
+        Shamanistic: EnumCase({ type: null }),
+    }),
+});
+export const MagicalTraditionPrerequisite = TypeAlias(import.meta.url, {
+    name: "MagicalTraditionPrerequisite",
+    type: () => Object({
+        restriction: Optional({
+            comment: "The magical tradition prerequisite may only be satified if the magical tradition can learn rituals or can bind familiars.",
+            type: IncludeIdentifier(MagicalTraditionPrerequisiteRestriction),
+        }),
+        display_option: Optional({
+            type: IncludeIdentifier(DisplayOption),
+        }),
+    }),
+});
+const MagicalTraditionPrerequisiteRestriction = Enum(import.meta.url, {
+    name: "MagicalTraditionPrerequisiteRestriction",
+    comment: "The magical tradition prerequisite may only be satified if the magical tradition can learn rituals or can bind familiars.",
+    values: () => ({
+        CanLearnRituals: EnumCase({ type: null }),
+        CanBindFamiliars: EnumCase({ type: null }),
+    }),
+});