@optolith/database-schema 0.42.1

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

@@ -0,0 +1,16 @@
+import * as DB from "tsondb/schema/dsl";
+import { ProfessionIdentifier } from "../../_Identifier.js";
+import { DisplayOption } from "../DisplayOption.js";
+export const ProfessionPrerequisite = DB.TypeAlias(import.meta.url, {
+    name: "ProfessionPrerequisite",
+    comment: "Requires a specific profession.",
+    type: () => DB.Object({
+        id: DB.Required({
+            comment: "The profession’s identifier.",
+            type: ProfessionIdentifier(),
+        }),
+        displayOption: DB.Optional({
+            type: DB.IncludeIdentifier(DisplayOption),
+        }),
+    }),
+});

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

@@ -0,0 +1,16 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const PublicationPrerequisite: DB.TypeAlias<"PublicationPrerequisite", DB.Object<{
+    id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+        Hide: DB.EnumCase<null>;
+        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                Standalone: DB.EnumCase<null>;
+                Connected: DB.EnumCase<null>;
+            }, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                replacement: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;

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

@@ -0,0 +1,15 @@
+import * as DB from "tsondb/schema/dsl";
+import { PublicationIdentifier } from "../../_Identifier.js";
+import { DisplayOption } from "../DisplayOption.js";
+export const PublicationPrerequisite = DB.TypeAlias(import.meta.url, {
+    name: "PublicationPrerequisite",
+    type: () => DB.Object({
+        id: DB.Required({
+            comment: "The publication’s identifier.",
+            type: PublicationIdentifier(),
+        }),
+        display_option: DB.Optional({
+            type: DB.IncludeIdentifier(DisplayOption),
+        }),
+    }),
+});

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

@@ -0,0 +1,17 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const RacePrerequisite: DB.TypeAlias<"RacePrerequisite", DB.Object<{
+    id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    active: DB.MemberDecl<DB.Boolean, true>;
+    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+        Hide: DB.EnumCase<null>;
+        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                Standalone: DB.EnumCase<null>;
+                Connected: DB.EnumCase<null>;
+            }, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                replacement: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;

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

@@ -0,0 +1,19 @@
+import * as DB from "tsondb/schema/dsl";
+import { RaceIdentifier } from "../../_Identifier.js";
+import { DisplayOption } from "../DisplayOption.js";
+export const RacePrerequisite = DB.TypeAlias(import.meta.url, {
+    name: "RacePrerequisite",
+    comment: "Requires a specific race or one of a specific set of races. You can also provide an object to say whether the hero must meet one of the races or if the entry does not allow one of the races.",
+    type: () => DB.Object({
+        id: DB.Required({
+            comment: "The race’s identifier.",
+            type: RaceIdentifier(),
+        }),
+        active: DB.Required({
+            type: DB.Boolean(),
+        }),
+        display_option: DB.Optional({
+            type: DB.IncludeIdentifier(DisplayOption),
+        }),
+    }),
+});

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

@@ -0,0 +1,51 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const RatedMinimumNumberPrerequisite: DB.TypeAlias<"RatedMinimumNumberPrerequisite", DB.Object<{
+    number: DB.MemberDecl<DB.Integer, true>;
+    value: DB.MemberDecl<DB.Integer, true>;
+    targets: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RatedMinimumNumberPrerequisiteTarget", {
+        Skills: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"RatedMinimumNumberPrerequisiteSkillsTarget", DB.Object<{
+            targets: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+        }>, []>>>;
+        CombatTechniques: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"RatedMinimumNumberPrerequisiteCombatTechniquesTarget", DB.Object<{
+            group: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RatedMinimumNumberPrerequisiteCombatTechniquesTargetGroup", {
+                All: DB.EnumCase<null>;
+                Close: DB.EnumCase<null>;
+                Ranged: DB.EnumCase<null>;
+            }, []>>, true>;
+        }>, []>>>;
+        Spellworks: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"RatedMinimumNumberPrerequisiteSpellworksTarget", DB.Object<{
+            property: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        }>, []>>>;
+        Liturgies: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"RatedMinimumNumberPrerequisiteLiturgiesTarget", DB.Object<{
+            aspect: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        }>, []>>>;
+    }, []>>, true>;
+    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+        Hide: DB.EnumCase<null>;
+        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                Standalone: DB.EnumCase<null>;
+                Connected: DB.EnumCase<null>;
+            }, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                replacement: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;
+export declare const RatedMinimumNumberPrerequisiteSkillsTarget: DB.TypeAlias<"RatedMinimumNumberPrerequisiteSkillsTarget", DB.Object<{
+    targets: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+}>, []>;
+export declare const RatedMinimumNumberPrerequisiteCombatTechniquesTarget: DB.TypeAlias<"RatedMinimumNumberPrerequisiteCombatTechniquesTarget", DB.Object<{
+    group: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RatedMinimumNumberPrerequisiteCombatTechniquesTargetGroup", {
+        All: DB.EnumCase<null>;
+        Close: DB.EnumCase<null>;
+        Ranged: DB.EnumCase<null>;
+    }, []>>, true>;
+}>, []>;
+export declare const RatedMinimumNumberPrerequisiteSpellworksTarget: DB.TypeAlias<"RatedMinimumNumberPrerequisiteSpellworksTarget", DB.Object<{
+    property: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+}>, []>;
+export declare const RatedMinimumNumberPrerequisiteLiturgiesTarget: DB.TypeAlias<"RatedMinimumNumberPrerequisiteLiturgiesTarget", DB.Object<{
+    aspect: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+}>, []>;

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

@@ -0,0 +1,82 @@
+import * as DB from "tsondb/schema/dsl";
+import { AspectIdentifier, PropertyIdentifier, SkillIdentifier } from "../../_Identifier.js";
+import { DisplayOption } from "../DisplayOption.js";
+export const RatedMinimumNumberPrerequisite = DB.TypeAlias(import.meta.url, {
+    name: "RatedMinimumNumberPrerequisite",
+    type: () => DB.Object({
+        number: DB.Required({
+            comment: "The minimum number of skills that need to be on the defined minimum skill rating.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        value: DB.Required({
+            comment: "The minimum skill rating the defined minimum number of skills need to be on.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        targets: DB.Required({
+            comment: "The targets that contribute to satisfying the prerequisite.",
+            type: DB.IncludeIdentifier(RatedMinimumNumberPrerequisiteTarget),
+        }),
+        display_option: DB.Optional({
+            type: DB.IncludeIdentifier(DisplayOption),
+        }),
+    }),
+});
+const RatedMinimumNumberPrerequisiteTarget = DB.Enum(import.meta.url, {
+    name: "RatedMinimumNumberPrerequisiteTarget",
+    values: () => ({
+        Skills: DB.EnumCase({ type: DB.IncludeIdentifier(RatedMinimumNumberPrerequisiteSkillsTarget) }),
+        CombatTechniques: DB.EnumCase({
+            type: DB.IncludeIdentifier(RatedMinimumNumberPrerequisiteCombatTechniquesTarget),
+        }),
+        Spellworks: DB.EnumCase({
+            type: DB.IncludeIdentifier(RatedMinimumNumberPrerequisiteSpellworksTarget),
+        }),
+        Liturgies: DB.EnumCase({
+            type: DB.IncludeIdentifier(RatedMinimumNumberPrerequisiteLiturgiesTarget),
+        }),
+    }),
+});
+export const RatedMinimumNumberPrerequisiteSkillsTarget = DB.TypeAlias(import.meta.url, {
+    name: "RatedMinimumNumberPrerequisiteSkillsTarget",
+    type: () => DB.Object({
+        targets: DB.Required({
+            comment: "The skills that are taken into account for satisfying the prerequisite.",
+            type: DB.Array(SkillIdentifier(), { minItems: 2, uniqueItems: true }),
+        }),
+    }),
+});
+export const RatedMinimumNumberPrerequisiteCombatTechniquesTarget = DB.TypeAlias(import.meta.url, {
+    name: "RatedMinimumNumberPrerequisiteCombatTechniquesTarget",
+    type: () => DB.Object({
+        group: DB.Required({
+            comment: "The skills that are taken into account for satisfying the prerequisite.",
+            type: DB.IncludeIdentifier(RatedMinimumNumberPrerequisiteCombatTechniquesTargetGroup),
+        }),
+    }),
+});
+const RatedMinimumNumberPrerequisiteCombatTechniquesTargetGroup = DB.Enum(import.meta.url, {
+    name: "RatedMinimumNumberPrerequisiteCombatTechniquesTargetGroup",
+    values: () => ({
+        All: DB.EnumCase({ type: null }),
+        Close: DB.EnumCase({ type: null }),
+        Ranged: DB.EnumCase({ type: null }),
+    }),
+});
+export const RatedMinimumNumberPrerequisiteSpellworksTarget = DB.TypeAlias(import.meta.url, {
+    name: "RatedMinimumNumberPrerequisiteSpellworksTarget",
+    type: () => DB.Object({
+        property: DB.Required({
+            comment: "The skills that are taken into account for satisfying the prerequisite.",
+            type: PropertyIdentifier(),
+        }),
+    }),
+});
+export const RatedMinimumNumberPrerequisiteLiturgiesTarget = DB.TypeAlias(import.meta.url, {
+    name: "RatedMinimumNumberPrerequisiteLiturgiesTarget",
+    type: () => DB.Object({
+        aspect: DB.Required({
+            comment: "The skills that are taken into account for satisfying the prerequisite.",
+            type: AspectIdentifier(),
+        }),
+    }),
+});

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

@@ -0,0 +1,26 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const RatedPrerequisite: DB.TypeAlias<"RatedPrerequisite", DB.Object<{
+    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RatedIdentifier", {
+        Attribute: DB.EnumCase<DB.ReferenceIdentifier>;
+        Skill: DB.EnumCase<DB.ReferenceIdentifier>;
+        CloseCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+        RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+        Spell: DB.EnumCase<DB.ReferenceIdentifier>;
+        Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
+        LiturgicalChant: DB.EnumCase<DB.ReferenceIdentifier>;
+        Ceremony: DB.EnumCase<DB.ReferenceIdentifier>;
+    }, []>>, true>;
+    value: DB.MemberDecl<DB.Integer, true>;
+    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+        Hide: DB.EnumCase<null>;
+        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                Standalone: DB.EnumCase<null>;
+                Connected: DB.EnumCase<null>;
+            }, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                replacement: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;

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

@@ -0,0 +1,19 @@
+import * as DB from "tsondb/schema/dsl";
+import { RatedIdentifier } from "../../_IdentifierGroup.js";
+import { DisplayOption } from "../DisplayOption.js";
+export const RatedPrerequisite = DB.TypeAlias(import.meta.url, {
+    name: "RatedPrerequisite",
+    type: () => DB.Object({
+        id: DB.Required({
+            comment: "The rated entry’s identifier.",
+            type: DB.IncludeIdentifier(RatedIdentifier),
+        }),
+        value: DB.Required({
+            comment: "The required minimum value.",
+            type: DB.Integer({ minimum: 0 }),
+        }),
+        display_option: DB.Optional({
+            type: DB.IncludeIdentifier(DisplayOption),
+        }),
+    }),
+});

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

@@ -0,0 +1,17 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const RatedSumPrerequisite: DB.TypeAlias<"RatedSumPrerequisite", DB.Object<{
+    sum: DB.MemberDecl<DB.Integer, true>;
+    targets: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+        Hide: DB.EnumCase<null>;
+        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                Standalone: DB.EnumCase<null>;
+                Connected: DB.EnumCase<null>;
+            }, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                replacement: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;

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

@@ -0,0 +1,19 @@
+import * as DB from "tsondb/schema/dsl";
+import { SkillIdentifier } from "../../_Identifier.js";
+import { DisplayOption } from "../DisplayOption.js";
+export const RatedSumPrerequisite = DB.TypeAlias(import.meta.url, {
+    name: "RatedSumPrerequisite",
+    type: () => DB.Object({
+        sum: DB.Required({
+            comment: "The minimum required sum of the targets’ ratings.",
+            type: DB.Integer({ minimum: 0 }),
+        }),
+        targets: DB.Required({
+            comment: "The targets that are included in calculating the sum.",
+            type: DB.Array(SkillIdentifier(), { minItems: 2 }),
+        }),
+        display_option: DB.Optional({
+            type: DB.IncludeIdentifier(DisplayOption),
+        }),
+    }),
+});

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

@@ -0,0 +1,19 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const RulePrerequisite: DB.TypeAlias<"RulePrerequisite", DB.Object<{
+    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ExtensionRuleIdentifier", {
+        FocusRule: DB.EnumCase<DB.ReferenceIdentifier>;
+        OptionalRule: DB.EnumCase<DB.ReferenceIdentifier>;
+    }, []>>, true>;
+    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+        Hide: DB.EnumCase<null>;
+        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                Standalone: DB.EnumCase<null>;
+                Connected: DB.EnumCase<null>;
+            }, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                replacement: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;

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

@@ -0,0 +1,15 @@
+import * as DB from "tsondb/schema/dsl";
+import { ExtensionRuleIdentifier } from "../../_IdentifierGroup.js";
+import { DisplayOption } from "../DisplayOption.js";
+export const RulePrerequisite = DB.TypeAlias(import.meta.url, {
+    name: "RulePrerequisite",
+    comment: "Requires a specific extension rule (focus rule or optional rule) to be used/active.",
+    type: () => DB.Object({
+        id: DB.Required({
+            type: DB.IncludeIdentifier(ExtensionRuleIdentifier),
+        }),
+        display_option: DB.Optional({
+            type: DB.IncludeIdentifier(DisplayOption),
+        }),
+    }),
+});

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

@@ -0,0 +1,19 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const SexPrerequisite: DB.TypeAlias<"SexPrerequisite", DB.Object<{
+    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"BinarySex", {
+        Male: DB.EnumCase<null>;
+        Female: DB.EnumCase<null>;
+    }, []>>, true>;
+    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+        Hide: DB.EnumCase<null>;
+        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                Standalone: DB.EnumCase<null>;
+                Connected: DB.EnumCase<null>;
+            }, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                replacement: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;

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

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

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

@@ -0,0 +1,7 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const SexualCharacteristicPrerequisite: DB.TypeAlias<"SexualCharacteristicPrerequisite", DB.Object<{
+    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SexualCharacteristic", {
+        Penis: DB.EnumCase<null>;
+        Vagina: DB.EnumCase<null>;
+    }, []>>, true>;
+}>, []>;

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

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

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

@@ -0,0 +1,16 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const SocialStatusPrerequisite: DB.TypeAlias<"SocialStatusPrerequisite", DB.Object<{
+    id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+        Hide: DB.EnumCase<null>;
+        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                Standalone: DB.EnumCase<null>;
+                Connected: DB.EnumCase<null>;
+            }, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                replacement: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;

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

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

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

@@ -0,0 +1,16 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const StatePrerequisite: DB.TypeAlias<"StatePrerequisite", DB.Object<{
+    id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+        Hide: DB.EnumCase<null>;
+        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                Standalone: DB.EnumCase<null>;
+                Connected: DB.EnumCase<null>;
+            }, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                replacement: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;

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

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

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

@@ -0,0 +1,19 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const TextPrerequisite: DB.TypeAlias<"TextPrerequisite", DB.Object<{
+    verification: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"TextVerificationRule", {
+        Pass: DB.EnumCase<null>;
+        Deny: DB.EnumCase<null>;
+    }, []>>, true>;
+    sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+        Standalone: DB.EnumCase<null>;
+        Connected: DB.EnumCase<null>;
+    }, []>>, false>;
+    is_meta: DB.MemberDecl<DB.Boolean, false>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"TextPrerequisiteTranslation", {
+        text: DB.MemberDecl<DB.String, true>;
+    }>, true>;
+}>, []>;
+export declare const SentenceType: DB.Enum<"SentenceType", {
+    Standalone: DB.EnumCase<null>;
+    Connected: DB.EnumCase<null>;
+}, []>;

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

@@ -0,0 +1,53 @@
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "../../Locale.js";
+export const TextPrerequisite = DB.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: () => DB.Object({
+        verification: DB.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: DB.IncludeIdentifier(TextVerificationRule),
+        }),
+        sentence_type: DB.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: DB.IncludeIdentifier(SentenceType),
+        }),
+        is_meta: DB.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: DB.Boolean(),
+        }),
+        translations: NestedTranslationMap(DB.Required, "TextPrerequisite", DB.Object({
+            text: DB.Required({
+                comment: "The displayed text.",
+                type: DB.String({ minLength: 1, markdown: "inline" }),
+            }),
+        })),
+    }),
+});
+const TextVerificationRule = DB.Enum(import.meta.url, {
+    name: "TextVerificationRule",
+    values: () => ({
+        Pass: DB.EnumCase({ type: null }),
+        Deny: DB.EnumCase({ type: null }),
+    }),
+});
+export const SentenceType = DB.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: DB.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: DB.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

@@ -0,0 +1,37 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const BlessedTraditionPrerequisite: DB.TypeAlias<"BlessedTraditionPrerequisite", DB.Object<{
+    restriction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"BlessedTraditionPrerequisiteRestriction", {
+        Church: DB.EnumCase<null>;
+        Shamanistic: DB.EnumCase<null>;
+    }, []>>, false>;
+    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+        Hide: DB.EnumCase<null>;
+        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                Standalone: DB.EnumCase<null>;
+                Connected: DB.EnumCase<null>;
+            }, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                replacement: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;
+export declare const MagicalTraditionPrerequisite: DB.TypeAlias<"MagicalTraditionPrerequisite", DB.Object<{
+    restriction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"MagicalTraditionPrerequisiteRestriction", {
+        CanLearnRituals: DB.EnumCase<null>;
+        CanBindFamiliars: DB.EnumCase<null>;
+    }, []>>, false>;
+    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+        Hide: DB.EnumCase<null>;
+        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                Standalone: DB.EnumCase<null>;
+                Connected: DB.EnumCase<null>;
+            }, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                replacement: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+}>, []>;

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

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